@lcap/nasl 3.7.0-beta.4 → 3.7.0-beta.6

package/src/concepts/TriggerLauncher__.ts

@@ -26,6 +26,7 @@ import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import BaseNode from '../common/BaseNode';
 import Identifier from './Identifier__';
+import ConnectorTriggerLauncher from './ConnectorTriggerLauncher__';
 
 /**
  * 触发器启动器
@@ -47,7 +48,7 @@ export class TriggerLauncher extends BaseNode {
    */
   @property('concept')
   // @ts-ignore
-  readonly concept!: 'TriggerLauncher' | 'MsgTriggerLauncher';
+  readonly concept!: 'TriggerLauncher' | 'ConnectorTriggerLauncher' | 'MsgTriggerLauncher';
   /**
    * 触发器启动器名称
    */
@@ -162,8 +163,24 @@ export class TriggerLauncher extends BaseNode {
     let code = '';
     code += `export function ${self.name} () {\n`;
     try {
+      // console.log('test', self.connectorTrigger?.triggerEvent.callBackLogic.typeArguments[0])
       // 仅仅作引用查找不需要入参校验
-      code += `${self.callBackLogicKey}`;
+      if (self.concept === 'ConnectorTriggerLauncher') {
+        const connectorTrigger = (self as unknown as ConnectorTriggerLauncher).connectorTrigger
+        let stashParams = ''
+        if (connectorTrigger?.triggerEvent?.callBackLogic?.typeArguments?.[0]) {
+          stashParams = 'params'
+          code += `let params:`
+          code +=  `${yield* connectorTrigger?.triggerEvent?.callBackLogic?.typeArguments?.[0]?.toEmbeddedTS?.(shiftState(state, code))}\n`
+        }
+        code += `let result`;
+        if (connectorTrigger?.triggerEvent?.callBackLogic?.returnType?.[0]) {
+          code += `:${yield* connectorTrigger?.triggerEvent?.callBackLogic?.returnType?.[0]?.toEmbeddedTS?.(shiftState(state, code))}`
+        }
+        code += ` = ${self.callBackLogicKey}(${stashParams})`;
+      } else {
+        code += `${self.callBackLogicKey}`;
+      }
       code += ';\n';
       code += '}\n';
     } catch (error) {

package/src/concepts/ViewElement__.ts

@@ -1417,6 +1417,7 @@ export class ViewElement extends BaseNode {
     return this.view || (this?.getAncestor('BusinessComponent') as BusinessComponent);
   }
 
+
   /* 主页面有没有权限 */
   get parentAuth() {
     const _nameSpace = this.view.getNamespace();
@@ -3179,7 +3180,16 @@ export class ViewElement extends BaseNode {
       { node: this },
     );
   }
-
+  // 查找element下有没有某个类型的元素，有就返回
+  findElementItem(conceptName: string): ViewElement {
+    return utils.traverse(
+      (current) => {
+        if (current.node.concept === conceptName) return current.node;
+      },
+      { node: this },
+      { mode: 'anyObject', excludedKeySet: this.JSON_EXCLUDED_KEYS },
+    );
+  }
   @excludedInJSON()
   computedStyle: object = {};
   getCurrentName() {

package/src/concepts/View__.ts

@@ -1753,9 +1753,8 @@ export class View extends BaseNode {
    */
   genScript() {
     const componentList: Array<ViewElement> = [];
-    const componentListExtra: Array<ViewElement> = [];
-    this.elementsAttrs(this.elements, componentList);
-    this.elementsAttrsAll(this.elements, componentListExtra);
+    const allComponentList: Array<ViewElement & { currentIndex: number }> = [];
+    this.elementsAttrs(this.elements, componentList, allComponentList, -1);
 
     const crumbI18n =
       this.frontend?.i18nInfo?.enabled && this.crumb?.value && this.crumb?.i18nKey ? this.crumb.i18nKey : undefined;
@@ -1773,7 +1772,7 @@ export class View extends BaseNode {
       viewBindEvents: this.getViewBindEvents(),
       viewExpressions: this.getViewExpressions(),
       elements: componentList,
-      elementsAll: componentListExtra,
+      elementsAll: allComponentList,
     };
     let code = '';
     let mixin = '';
@@ -1926,27 +1925,20 @@ export class View extends BaseNode {
   }
 
   // 获取当前element，铺平
-  elementsAttrs(elements: Array<ViewElement>, componentList: Array<ViewElement>) {
+  elementsAttrs(elements: Array<ViewElement>, componentList: Array<ViewElement>, allComponentList: Array<ViewElement & {currentIndex: number}>, currentIndex: number) {
     if (elements) {
-      elements.forEach((item: ViewElement) => {
+      elements.forEach((item: ViewElement & { currentIndex: number }) => {
+        let index = currentIndex ?? -1
+        if (item.tag === 'template' && item.haveScope()) {
+          index += 1;
+        }
         if (ComponentCompletionPropertyMap[item.tag]) {
           componentList.push(item);
         }
+        item.currentIndex = index;
+        allComponentList.push(item)
         if (item.children.length > 0) {
-          this.elementsAttrs(item.children, componentList);
-        }
-      });
-    }
-  }
-
-  elementsAttrsAll(elements: Array<ViewElement>, componentListExtra: Array<ViewElement>) {
-    if (elements) {
-      elements.forEach((item: ViewElement) => {
-        if (!ComponentCompletionPropertyMap[item.tag]) {
-          componentListExtra.push(item);
-        }
-        if (item.children.length > 0) {
-          this.elementsAttrsAll(item.children, componentListExtra);
+          this.elementsAttrs(item.children, componentList, allComponentList, index);
         }
       });
     }

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

@@ -61,6 +61,7 @@ export function initialize() {
     }),
     new Logic({
       name: 'getWeChatOpenid',
+      description: '获取微信openid',
       params: [],
       body: [],
       returns: [
@@ -72,6 +73,7 @@ export function initialize() {
     }),
     new Logic({
       name: 'getWeChatNickName',
+      description: '获取微信昵称',
       params: [],
       body: [],
       returns: [
@@ -83,6 +85,7 @@ export function initialize() {
     }),
     new Logic({
       name: 'getWeChatPhone',
+      description: '获取微信手机号',
       params: [],
       body: [],
       returns: [
@@ -94,6 +97,31 @@ export function initialize() {
     }),
     new Logic({
       name: 'getWeChatHeadImg',
+      description: '获取微信头像',
+      params: [],
+      body: [],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+    }),
+    new Logic({
+      name: 'getWeChatLocation',
+      description: '获取微信定位',
+      params: [],
+      body: [],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+    }),
+    new Logic({
+      name: 'getWeChatScanCode',
+      description: '获取微信二维码内容',
       params: [],
       body: [],
       returns: [
@@ -105,11 +133,25 @@ export function initialize() {
     }),
     new Logic({
       name: 'navigateToUserInfo',
+      description: '跳转到微信昵称头像获取页面',
       params: [],
       body: [],
     }),
     new Logic({
       name: 'navigateToUserPhone',
+      description: '跳转到微信手机号获取页面',
+      params: [],
+      body: [],
+    }),
+    new Logic({
+      name: 'navigateToScanCode',
+      description: '跳转到微信扫一扫页面',
+      params: [],
+      body: [],
+    }),
+    new Logic({
+      name: 'navigateToLocation',
+      description: '跳转到微信定位页面',
       params: [],
       body: [],
     }),

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

@@ -75,6 +75,14 @@ export function initialize() {
     Enum.from(
       {
         name: 'I18nEnum',
+        label: '国际化多语言枚举',
+        description: '国际化多语言功能涉及的所有可选语言',
+        valueType: {
+          concept: 'TypeAnnotation',
+          typeKind: 'primitive',
+          typeNamespace: 'nasl.core',
+          typeName: 'String',
+        },
         enumItems: languageList.map((item) => {
           return new EnumItem({
             label: new StaticString({

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 节点断言失败`);
+  }
+}
+