@lcap/nasl 3.3.0-alpha.1 → 3.3.0-alpha.3

package/src/server/extendBaseNode.ts

@@ -1,5 +1,5 @@
-import * as tsProtocol from 'typescript/lib/protocol';
 import { FileNode, NaslServer } from './naslServer';
+import * as tsProtocol from 'typescript/lib/protocol';
 import { MinRange } from './translator';
 import {
   BaseNode,
@@ -48,17 +48,19 @@ BaseNode.prototype.findReadOnlyLogicUsage = function () {
             targetNode = logic;
             break;
           }
-      } else if (logic instanceof Logic)
-        if (logic.calleewholeKey === (this.parentNode as Logic).calleewholeKey) {
-          targetNode = logic;
-          break;
-        }
+      } else {
+        if (logic instanceof Logic)
+          if (logic.calleewholeKey === (this.parentNode as Logic).calleewholeKey) {
+            targetNode = logic;
+            break;
+          }
+      }
     }
   } else if (this.parentNode.concept === 'Module') {
     // 父级是模块的还是用它本身去查找引用
     targetNode = this;
   } else {
-    const { sourceMap } = this.parentNode;
+    const sourceMap = this.parentNode.sourceMap;
     for (const item of sourceMap) {
       const logic = item[0] as Logic;
       if (logic.calleewholeKey && logic.calleewholeKey === (this as Logic).calleewholeKey) {
@@ -152,14 +154,16 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
               } else {
                 itemNode.setName?.(item.newValue);
               }
-            } else if (_this.concept === 'AuthLogicForCallInterface' && itemNode.concept === 'CallAuthInterface') {
-              const { calleewholeKey } = itemNode;
-              const targetItf: AuthInterface = getNodeByNodeCallee(App, calleewholeKey);
-              targetItf.setAuthLogic(newValue);
-              // 需要触发更新，否则对应的ts文件不会更新会导致鉴权方式找不到报错
-              itemNode.update({});
             } else {
-              item.setTypeMethods ? itemNode[item.setTypeMethods](newValue) : itemNode.setName?.(newValue);
+              if (_this.concept === 'AuthLogicForCallInterface' && itemNode.concept === 'CallAuthInterface') {
+                const { calleewholeKey } = itemNode;
+                const targetItf: AuthInterface = getNodeByNodeCallee(App, calleewholeKey);
+                targetItf.setAuthLogic(newValue);
+                // 需要触发更新，否则对应的ts文件不会更新会导致鉴权方式找不到报错
+                itemNode.update({});
+              } else {
+                item.setTypeMethods ? itemNode[item.setTypeMethods](newValue) : itemNode.setName?.(newValue);
+              }
             }
           });
           // 结束修改 ，批量操作
@@ -181,19 +185,21 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
       const closeCallBack = () => {
         if (this.concept === 'EnumItem') {
           const oldValue = (this as EnumItem).value;
-          (this as EnumItem).value = `${oldValue} `;
+          (this as EnumItem).value = oldValue + ' ';
           setTimeout(() => {
             (this as EnumItem).value = oldValue;
           }, 0);
         } else {
           const oldValue = this.name;
-          this.name = `${oldValue} `;
+          this.name = oldValue + ' ';
           setTimeout(() => {
             this.name = oldValue;
           }, 0);
         }
       };
       updateAll ? callback(true) : invokeCommand('tsConfirm.open', confirmParms, callback, closeCallBack);
+
+      return;
     }
   } catch (err) {
     console.log(err);
@@ -233,6 +239,11 @@ BaseNode.prototype.prepareDelete = async function prepareDelete(cb?: Function) {
         return;
       }
       callback = () => {
+        // 外部接口删除时，只需要删除自己，不需要删除数据结构
+        if (node instanceof Interface && node.parentNode.concept === 'App') {
+          this.delete();
+          return;
+        }
         // Structure 和 Interface是内部有delete方法
         if (node instanceof Structure || node instanceof Interface) {
           (this as any).deleteLogincAndModule();
@@ -275,32 +286,33 @@ BaseNode.prototype.prepareDelete = async function prepareDelete(cb?: Function) {
             }
           }
           return;
-        }
-        if (node instanceof Frontend) {
-          let viewPath = (this as FileNode).getEmbeddedFilePath();
-          viewPath = viewPath.slice(0, viewPath.length - 3);
-          const refsTempList = refsList.filter((record) => !record.file.includes(viewPath));
-          // 删除流程节点绑定的该端的页面跳转
-          const result = refsTempList
-            .map((record) => {
-              const fileNode = naslServer.file2NodeMap.get(record.file);
-              if (fileNode) {
-                const minRange = naslServer._findMinRange(record, fileNode as FileNode);
-                if (minRange?.node?.parentNode?.parentNode?.concept === 'ProcessElement') {
-                  return minRange.node.parentNode;
+        } else {
+          if (node instanceof Frontend) {
+            let viewPath = (this as FileNode).getEmbeddedFilePath();
+            viewPath = viewPath.slice(0, viewPath.length - 3);
+            const refsTempList = refsList.filter((record) => !record.file.includes(viewPath));
+            // 删除流程节点绑定的该端的页面跳转
+            const result = refsTempList
+              .map((record) => {
+                const fileNode = naslServer.file2NodeMap.get(record.file);
+                if (fileNode) {
+                  const minRange = naslServer._findMinRange(record, fileNode as FileNode);
+                  if (minRange?.node?.parentNode?.parentNode?.concept === 'ProcessElement') {
+                    return minRange.node.parentNode;
+                  }
                 }
-              }
-              return null;
-            })
-            .filter((record) => !!record);
-          const App = this.rootNode;
-          App.emit('collect:start', {
-            actionMsg: `删除端${node.name}`,
-          });
-          await Promise.all(result.map((ele) => ele.delete()));
-          this.delete();
-          App.emit('collect:end');
-          return;
+                return null;
+              })
+              .filter((record) => !!record);
+            const App = this.rootNode;
+            App.emit('collect:start', {
+              actionMsg: `删除端${node.name}`,
+            });
+            await Promise.all(result.map((ele) => ele.delete()));
+            this.delete();
+            App.emit('collect:end');
+            return;
+          }
         }
       }
       callback = async () => {
@@ -308,7 +320,7 @@ BaseNode.prototype.prepareDelete = async function prepareDelete(cb?: Function) {
         // 跟rename 还不太一样，部分修改依赖修改好的值，然后在下面的修改需要把自己传递进去
         if (node instanceof Param) {
           const App = this.rootNode;
-          const { parentNode } = this;
+          const parentNode = this.parentNode;
           // 收集修改
           App.emit('collect:start', {
             actionMsg: '删除参数',
@@ -401,6 +413,12 @@ BaseNode.prototype.prepareDelete = async function prepareDelete(cb?: Function) {
           App.emit('collect:end');
         }
 
+        // 外部接口删除时，只需要删除自己，不需要删除数据结构
+        if (node instanceof Interface && node.parentNode.concept === 'App') {
+          this.delete();
+          return;
+        }
+
         if (node instanceof Connection) {
           delConnection(node);
           if (cb) {
@@ -429,6 +447,14 @@ function delConnection(node: Connection) {
   app.emit('collect:start', {
     actionMsg: '删除连接器',
   });
+  if (node.connector?.connectorKind === 'kafka') {
+    // 删除相关的触发器
+    app.triggerLaunchers.forEach((launcher) => {
+      if ((launcher as MsgTriggerLauncher).calleeConnectionName === node.name) {
+        launcher.delete();
+      }
+    });
+  }
   node.delete();
   app.emit('collect:end');
 }
@@ -460,7 +486,7 @@ BaseNode.prototype.getCurrentTypeAnnotation = async function getCurrentTypeAnnot
      */
     const app = this.getAncestor('App');
     const naslServer = (app as any).naslServer as NaslServer;
-    return await naslServer.getCurrentTypeAnnotation(this, outTime || 2000);
+    return naslServer.getCurrentTypeAnnotation(this, outTime || 2000);
   } catch (err) {
     console.log(err);
   }
@@ -496,7 +522,7 @@ BaseNode.prototype.getSelectRef = function getSelectRef(newTypeAnnotation: TypeA
         } else {
           app = this.rootNode || typeAnnotation.app;
         }
-        const node = newNode(getNodeByNodeCallee(app, `${typeNamespace}.${typeName}`), parentNode, needNewStructure);
+        const node = newNode(getNodeByNodeCallee(app, typeNamespace + '.' + typeName), parentNode, needNewStructure);
         const properties = node?.properties || [];
         completionChildren = properties;
       }
@@ -508,7 +534,7 @@ BaseNode.prototype.getSelectRef = function getSelectRef(newTypeAnnotation: TypeA
         if (item?.typeAnnotation?.typeKind === 'typeParam') {
           if (item.name === 'columnItem' && typeArguments[1]) {
             item.typeAnnotation = TypeAnnotation.from(typeArguments[1].toJSON(), node, 'typeAnnotation');
-          } else {
+          } else if (typeArguments[0]) {
             item.typeAnnotation = TypeAnnotation.from(typeArguments[0].toJSON(), node, 'typeAnnotation');
           }
           properties[i];

package/src/server/formatTsUtils.ts

@@ -239,8 +239,7 @@ export function getPlatformType(type: string): string {
   const namespacePrefix = ['app', 'extensions', 'apis', 'components', 'nasl'];
   if (tsType === 'String') {
     return 'nasl.core.String';
-  }
-  if (tsType === 'Boolean') {
+  } else if (tsType === 'Boolean') {
     return 'nasl.core.Boolean';
   }
 
@@ -249,7 +248,7 @@ export function getPlatformType(type: string): string {
     const first = strTypes[0];
     // 如果不是这几个前缀就加一个namespace
     if (!namespacePrefix.includes(first)) {
-      return `app.${tsType}`;
+      return 'app.' + tsType;
     }
   }
   return tsType;
@@ -358,7 +357,7 @@ function getAStructureScopeType(type: string, parent: any, node: SynatxNode) {
             const name = itemArr[0];
             let typeKey = itemArr[1];
             if (typeKey && typeKey.startsWith('dataSources')) {
-              typeKey = `app.${typeKey}`;
+              typeKey = 'app.' + typeKey;
             }
             // 如果ls传过来的名字是不合法的就隐藏
             if (!isValidName(name)) {
@@ -393,8 +392,9 @@ function getAStructureScopeType(type: string, parent: any, node: SynatxNode) {
         });
         completionProperty.children = res;
         return completionProperty;
+      } else {
+        return completionProperty;
       }
-      return completionProperty;
     });
     parentItem.children = newChildren;
   }
@@ -512,36 +512,34 @@ function getNodeTypeVariableData(nodeType: any, item: any, node: SynatxNode) {
     const app = node.rootNode as App;
     let structure: any = {};
 
-    // 偶尔会报这个错误，先跳过吧
-    if (!typeAnnotation) {
-      return;
-    }
+    // 有类型在进行下一步运算
+    if (typeAnnotation) {
+      // 数据查询没有输出参数，特殊处理
+      if (typeAnnotation.typeKind === 'anonymousStructure') {
+        structure = { properties: typeAnnotation.properties };
+      } else if (typeAnnotation.typeArguments) {
+        structure = { properties: app.getSelectRef(typeAnnotation, true) };
+      } else {
+        structure = app.findNodeByCompleteName(typeAnnotation.typeNamespace + '.' + typeAnnotation.typeName);
+      }
+      structure?.properties?.forEach((structureProperty: StructureProperty) => {
+        const { name, typeAnnotation } = structureProperty;
+        const expression = new MemberExpression({
+          object: parentExpression,
+          property: new Identifier({ name }),
+        });
+        const completionData = new CompletionProperty({
+          name,
+          value: name,
+          expression,
+          children: [],
+        });
+        completionData.icon = 'refProperty';
 
-    // 数据查询没有输出参数，特殊处理
-    if (typeAnnotation.typeKind === 'anonymousStructure') {
-      structure = { properties: typeAnnotation.properties };
-    } else if (typeAnnotation.typeArguments) {
-      structure = { properties: app.getSelectRef(typeAnnotation, true) };
-    } else {
-      structure = app.findNodeByCompleteName(`${typeAnnotation.typeNamespace}.${typeAnnotation.typeName}`);
-    }
-    structure?.properties?.forEach((structureProperty: StructureProperty) => {
-      const { name, typeAnnotation } = structureProperty;
-      const expression = new MemberExpression({
-        object: parentExpression,
-        property: new Identifier({ name }),
+        item.children.push(completionData);
+        recursionProperty(typeAnnotation, completionData, node, typeKeyMap);
       });
-      const completionData = new CompletionProperty({
-        name,
-        value: name,
-        expression,
-        children: [],
-      });
-      completionData.icon = 'refProperty';
-
-      item.children.push(completionData);
-      recursionProperty(typeAnnotation, completionData, node, typeKeyMap);
-    });
+    }
   }
 
   const completionData = new CompletionProperty(item);
@@ -559,10 +557,12 @@ function recursionProperty(
   let structure;
   if (structureTypeAnnotation.typeArguments) {
     structure = { properties: app.getSelectRef(structureTypeAnnotation, true) };
-  } else if (structureTypeAnnotation.typeKind === 'anonymousStructure') {
-    structure = { properties: structureTypeAnnotation.properties };
   } else {
-    structure = app.findNodeByCompleteName(`${structureTypeAnnotation.typeNamespace}.${structureTypeAnnotation.typeName}`);
+    if (structureTypeAnnotation.typeKind === 'anonymousStructure') {
+      structure = { properties: structureTypeAnnotation.properties };
+    } else {
+      structure = app.findNodeByCompleteName(structureTypeAnnotation.typeNamespace + '.' + structureTypeAnnotation.typeName);
+    }
   }
 
   structure?.properties?.forEach((structureProperty: StructureProperty) => {
@@ -590,8 +590,7 @@ function getNextFlag(typeKey: string, typeKeyMap: Map<string, number>) {
   if (['nasl.core.String', 'nasl.collection.List', 'nasl.collection.Map'].includes(typeKey)) return true;
   if (typeKeyMap.get(typeKey) === 3) {
     return false;
-  }
-  if (typeKeyMap.get(typeKey) > 0) {
+  } else if (typeKeyMap.get(typeKey) > 0) {
     typeKeyMap.set(typeKey, typeKeyMap.get(typeKey) + 1);
   } else {
     typeKeyMap.set(typeKey, 1);
@@ -609,29 +608,28 @@ export function formatVariableData(data: unknown | variableItem[], node: SynatxN
         if (item.completionDetail?.hasOwnProperty('nodeType') || item.completionDetail?.hasOwnProperty('newNodeType')) {
           const completionProperty = getNodeTypeVariableData(item.completionDetail?.nodeType || item.completionDetail?.newNodeType, item, node);
           return completionProperty;
-        }
-        // 当前节点的完整类型，主要是在有T的内容使用 nasl.list<Enum1> 内部匹配内容给里面子集的T赋值类型
-        let currentType: string = formatTs2TypeString(item.completionDetail.displayParts as Array<{ text: string; kind: string }>);
-        if (currentType) {
-          if (currentType?.includes(': ')) {
-            const indexOf = currentType.indexOf(': ');
-            const newCurrentType = currentType.substring(indexOf + 2, currentType.length);
-            // 如果是对象形式的就单独处理
-            if (newCurrentType.startsWith('{') && newCurrentType.endsWith('}')) {
-              const completionProperty = getAStructureObjectStringType(newCurrentType, item, node);
-              return completionProperty;
-            }
-            if (newCurrentType.startsWith('nasl.ui.Current<{')) {
-              const completionProperty = getAStructureScopeType(newCurrentType, item, node);
-              return completionProperty;
-            }
-            if (newCurrentType.startsWith('nasl.collection.List<{') && newCurrentType.endsWith('}>')) {
-              currentType = 'nasl.collection.List<nasl.core.Any>';
+        } else {
+          // 当前节点的完整类型，主要是在有T的内容使用 nasl.list<Enum1> 内部匹配内容给里面子集的T赋值类型
+          let currentType: string = formatTs2TypeString(item.completionDetail.displayParts as Array<{ text: string; kind: string }>);
+          if (currentType) {
+            if (currentType?.includes(': ')) {
+              const indexOf = currentType.indexOf(': ');
+              const newCurrentType = currentType.substring(indexOf + 2, currentType.length);
+              // 如果是对象形式的就单独处理
+              if (newCurrentType.startsWith('{') && newCurrentType.endsWith('}')) {
+                const completionProperty = getAStructureObjectStringType(newCurrentType, item, node);
+                return completionProperty;
+              } else if (newCurrentType.startsWith('nasl.ui.Current<{')) {
+                const completionProperty = getAStructureScopeType(newCurrentType, item, node);
+                return completionProperty;
+              } else if (newCurrentType.startsWith('nasl.collection.List<{') && newCurrentType.endsWith('}>')) {
+                currentType = 'nasl.collection.List<nasl.core.Any>';
+              }
             }
           }
+          typeKey = getPlatformType(currentType);
+          item.typeAnnotation = displayString2TypeAnnotation(typeKey);
         }
-        typeKey = getPlatformType(currentType);
-        item.typeAnnotation = displayString2TypeAnnotation(typeKey);
       } else if (item instanceof StructureProperty || item instanceof EntityProperty) {
         typeKey = item?.typeAnnotation?.typeKey;
       }
@@ -733,15 +731,17 @@ function getNodeiconFromLogic(completionProperty: CompletionProperty, node: Syna
       if (params.find((item) => item.name === completionProperty.name)) return 'api-auth-params';
     } else if (logic instanceof AuthLogic) {
       if (params.find((item) => item.name === completionProperty.name)) return 'api-auth-params';
-    } else if (params.find((item) => item.name === completionProperty.name)) return 'param';
+    } else {
+      if (params.find((item) => item.name === completionProperty.name)) return 'param';
+    }
 
     if (params.find((item) => item.name === propName)) {
       return 'param';
-    }
-    if (returns.find((item) => item.name === propName)) {
+    } else if (returns.find((item) => item.name === propName)) {
       return 'return';
+    } else {
+      return 'variable';
     }
-    return 'variable';
   }
 
   const bindAttr = node.getAncestor<BindAttribute>('BindAttribute');
@@ -768,8 +768,8 @@ function getNodeiconFromLogic(completionProperty: CompletionProperty, node: Syna
  */
 function sortFirstVariableData(result: CompletionProperty[], node: BaseNode) {
   const newResult: CompletionProperty[] = [];
-  const { logic } = node as Param;
-  const { view } = node as Param;
+  const logic = (node as Param).logic;
+  const view = (node as Param).view;
   if (view) {
     const { params, variables } = view;
     const list = [...params, ...variables];

package/src/server/getLogics.ts

@@ -127,7 +127,7 @@ export async function getLogics(node: CallLogic | BindEvent | Identifier | Logic
         pItem.originConcept = 'Process';
         return pItem;
       });
-      const { dependencies } = app; // .filter((d) => d.enable);
+      const dependencies = app.dependencies; //.filter((d) => d.enable);
       const extensions = app.dependencies
         .map((dep) => moduleToLogicNamesapce(dep, app.overriddenLogics))
         .filter((item) => item.logics && item.logics.length);
@@ -213,8 +213,8 @@ export async function getLogics(node: CallLogic | BindEvent | Identifier | Logic
       elements.forEach((item) => {
         const itemTag = toHump(item.tag);
         const app = node.getAncestor('App');
-        const { naslServer } = app as any;
-        const { elementsLogic } = naslServer;
+        const naslServer = (app as any).naslServer;
+        const elementsLogic = naslServer.elementsLogic;
         const elementsLogicName = itemTag;
         const eleLogis = elementsLogic[elementsLogicName];
         // 看是不是有已经有有参数的函数了
@@ -292,32 +292,26 @@ export async function getLogics(node: CallLogic | BindEvent | Identifier | Logic
        * 在绑定事件中，且event中支持事件逻辑时
        */
       // FIXME 先用白名单的方式支持
-      const { parentNode } = node;
-      const grandParentNode = parentNode?.parentNode;
-      if (
-        grandParentNode.concept === 'BindEvent' &&
-        parentNode.concept === 'Logic' &&
-        parentNode.virtualParams?.length &&
-        ['KeyboardEvent'].includes(parentNode.virtualParams[0]?.__TypeAnnotation?.typeName)
-      ) {
-        systemTree.children[1].logics.push(compareKeyboardInput);
-      }
 
-      if (
-        grandParentNode.concept === 'BindEvent' &&
-        parentNode.concept === 'Logic' &&
-        parentNode.virtualParams?.length &&
-        ['MouseEvent', 'KeyboardEvent'].includes(parentNode.virtualParams[0]?.__TypeAnnotation?.typeName)
-      ) {
-        systemTree.children.push(
-          new Namespace({
-            name: 'category',
-            path: `event`,
-            title: '事件逻辑',
-            logics: stdlibNamespace.findChild('event').logics,
-            expanded: false,
-          })
-        );
+      // 查找祖先节点
+      const bindEventNode = node.getAncestor('BindEvent');
+      if (bindEventNode && (bindEventNode as BindEvent).logics.length) {
+        const logicNode = (bindEventNode as BindEvent).logics[0];
+        if (logicNode.virtualParams?.length && ['KeyboardEvent'].includes(logicNode.virtualParams[0]?.__TypeAnnotation?.typeName)) {
+          systemTree.children[1].logics.push(compareKeyboardInput);
+        }
+
+        if (logicNode.virtualParams?.length && ['MouseEvent', 'KeyboardEvent'].includes(logicNode.virtualParams[0]?.__TypeAnnotation?.typeName)) {
+          systemTree.children.push(
+            new Namespace({
+              name: 'category',
+              path: `event`,
+              title: '事件逻辑',
+              logics: stdlibNamespace.findChild('event').logics,
+              expanded: false,
+            })
+          );
+        }
       }
       /**
        * end
@@ -402,8 +396,7 @@ export async function getLogics(node: CallLogic | BindEvent | Identifier | Logic
       result.push(systemTree);
     }
     return result;
-  }
-  if (node?.concept === 'Identifier') {
+  } else if (node?.concept === 'Identifier') {
     const extensions = app.dependencies
       .map((dep) => moduleToLogicNamesapce(dep, app.overriddenLogics))
       .filter((item) => item.logics && item.logics.length);

package/src/server/getMemberIdentifier.ts

@@ -12,6 +12,8 @@ import {
   Frontend,
   View,
   SynatxNode,
+  ViewElement,
+  PAGE_COMPONENT_INCLUDE_TAG_MAP,
 } from '..';
 import { formatVariableData, formatFrontEndVariables, formatConfigProperties, formatBackendVariables } from './formatTsUtils';
 
@@ -225,6 +227,9 @@ export async function getMemberIdentifier(node: SynatxNode) {
       // 获取前端全局变量
       const frontEndVariable = getFrontEndVariablesIdentifier((node as Identifier).view || (node as Identifier).frontend);
       result.push({ name: '前端全局变量', children: frontEndVariable, expanded: true, icon: 'category' });
+      // 获取页面组件
+      const pageComponents = await getPageComponentsIdentifier(node);
+      result.push({ name: '页面组件', children: pageComponents, expanded: true, icon: 'category' });
     } else if (!(node as Identifier).frontend) {
       // 端事件里既不能调用前端变量 也不能调用后端变量
       const BackEndglobalVariable = getBackendVariablesIdentifier(node);
@@ -348,3 +353,141 @@ export function getConfigsIdentifier(node: BaseNode): CompletionProperty[] {
   });
   return newProperties.concat(extensionConfigProperties);
 }
+function flatElements(elements: ViewElement[], componentList: CompletionProperty[], nodeParentElement: string, currentAttriBute: string) {
+  elements.forEach((item) => {
+      if (PAGE_COMPONENT_INCLUDE_TAG_MAP?.[item.tag]) {
+          console.log('componentItem', item)
+          const current = item.name === nodeParentElement
+          const stashItem: any = {
+              name: `${item.name}${current ? '(当前组件)' : ''}`,
+              value: item.name,
+              expression: new Identifier({
+                  name: current ? '当前组件' : item.name,
+                  namespace: `elements.${current ? '$ce' : item.name}.property`
+              }),
+              children: [],
+          };
+          const attrsList = item.bindAttrs.filter((attr) => {
+              if (PAGE_COMPONENT_INCLUDE_TAG_MAP[item.tag]?.[attr.name]) {
+                  if (current && attr.name === currentAttriBute) {
+                      return false
+                  } else {
+                      return true
+                  }
+              }
+          })
+          attrsList.forEach((attr) => {
+              const currentAttrInfo = PAGE_COMPONENT_INCLUDE_TAG_MAP[ item.tag]?.[attr.name]
+              if (attr.name !== 'sorting') {
+                  const stashAttr: any = {
+                      ...attr,
+                      name: attr.name,
+                      value: `${item.name}.${attr.name}`,
+                      expression: new MemberExpression({
+                          object: stashItem.expression,
+                          property: new Identifier({
+                              name: currentAttrInfo.value,
+                              namespace: attr.name
+                          }),
+                      }),
+                  };
+                  const completionProperty = new CompletionProperty(stashAttr);
+                  completionProperty.name = currentAttrInfo ? `${currentAttrInfo.value}（${currentAttrInfo.label}）` : attr.name;
+                  completionProperty.icon = 'attr'
+                  stashItem.children.push(completionProperty)
+              }
+          })
+          if (['u-select', 'van-pickerson'].includes(item.tag)) {
+              const pageAttr: any = {
+                  name: 'page-number',
+                  value: `${item.name}.page-number`,
+                  expression: new MemberExpression({
+                      object: stashItem.expression,
+                      property: new Identifier({
+                          name: 'page',
+                          namespace: 'page-number'
+                      }),
+                  }),
+              };
+              const completionProperty = new CompletionProperty(pageAttr);
+              completionProperty.name = 'page（当前页数）';
+              completionProperty.icon = 'attr'
+              stashItem.children.push(completionProperty)
+          } else if (['u-list-view', 'u-grid-view', 'u-table-view', 'van-list-view', 'van-grid-view'].includes(item.tag)) {
+              const sortAttr: any = {
+                  name: 'sort',
+                  value: `${item.name}.sort`,
+                  expression: new MemberExpression({
+                      object: stashItem.expression,
+                      property: new Identifier({
+                          name: 'sort',
+                          namespace: 'sorting.field'
+                      }),
+                  }),
+              };
+              const sortCompletionProperty = new CompletionProperty(sortAttr);
+              sortCompletionProperty.name = 'sort（排序属性）';
+              sortCompletionProperty.icon = 'attr'
+              stashItem.children.push(sortCompletionProperty)
+              const orderAttr: any = {
+                  name: 'order',
+                  value: `${item.name}.order`,
+                  expression: new MemberExpression({
+                      object: stashItem.expression,
+                      property: new Identifier({
+                          name: 'order',
+                          namespace: 'sorting.order'
+                      }),
+                  }),
+              };
+              const orderCompletionProperty = new CompletionProperty(orderAttr);
+              orderCompletionProperty.name = 'order（排序顺序）';
+              orderCompletionProperty.icon = 'attr'
+              stashItem.children.push(orderCompletionProperty)
+          }
+          const completionProperty = new CompletionProperty(stashItem);
+          completionProperty.icon = 'element';
+          if (current) {
+              componentList.unshift(completionProperty)
+          } else {
+              componentList.push(completionProperty)
+          }
+      }
+      if (item.children.length > 0) {
+          flatElements(item.children, componentList, nodeParentElement, currentAttriBute)
+      }
+  })
+}
+// 获取页面组件
+export function getPageComponentsIdentifier(node: SynatxNode): CompletionProperty[] {
+  const { fileNode } = node.getCurrentSource();
+  const stashElements = (fileNode as View).elements;
+  const componentList: CompletionProperty[] = []
+  const nodeParentElement = getCurrentElement(node)?.name
+  const currentAttriBute = getCurrentAttriBute(node)?.name
+  flatElements(stashElements, componentList, nodeParentElement, currentAttriBute)
+  return componentList
+}
+
+function getCurrentElement(item: any): ViewElement | undefined {
+  if (!item?.parentNode) return undefined
+  if (item.parentNode?.concept === 'ViewElement') {
+      return item.parentNode
+  } else if (item.parentNode?.concept === 'View') {
+      return  undefined
+  } else {
+      return getCurrentElement(item.parentNode)
+  }
+}
+
+function getCurrentAttriBute(item: any): BindAttribute | undefined {
+  if (item.concept === 'BindAttribute') {
+      return item
+  } else {
+      if (item?.parentNode && item.parentNode?.concept !== 'View') {
+          return getCurrentAttriBute(item.parentNode)
+      } else {
+          return undefined
+      }
+  }
+}