@lcap/nasl 3.8.2-beta.7 → 3.8.2-beta.9

package/src/concepts/ViewElement__.ts

@@ -27,7 +27,6 @@ import type Identifier from './Identifier__';
 import { PAGE_COMPONENT_INCLUDE_TAG_MAP } from './View__';
 import type BusinessComponent from './BusinessComponent__';
 import type FrontendType from './FrontendType__';
-import { ComponentCompletionPropertyMap } from './View__';
 
 import { kebab2Camel } from '../utils';
 export interface ParseContext {
@@ -1777,7 +1776,7 @@ export class ViewElement extends Annotatable {
     if (hasDataSource && V && !T1) {
       const valueFieldAttr = self.bindAttrs?.find((attr) => attr.name === 'valueField');
       if (dataSourceSetted && ['static', 'string'].includes(valueFieldAttr?.type)) {
-        valueType = `nasl.util._formatEnum<typeof __item.${valueFieldAttr.value}>`;
+        valueType = `nasl.util._formatEnum<typeof __item.${valueFieldAttr.value || 'value'}>`;
       } else {
         valueType = `nasl.util._formatEnum<typeof __staticItem>`;
       }
@@ -1915,7 +1914,6 @@ export class ViewElement extends Annotatable {
               noNeedParams: true,
               callLogicNoIife: true,
             };
-            debugger;
             const value = yield* attr.expression.toEmbeddedTS(
               shiftState(state, code, attr.expression.concept === 'CallLogic' ? extraParams : {}),
             );
@@ -3186,6 +3184,7 @@ export class ViewElement extends Annotatable {
 
         result && parts.push(result);
       });
+    let preAnnoParts:any = []
     const genDirectiveByAnno = (viewElement: ViewElement) => {
       if (viewElement?.applyAnnotations?.length > 0) {
         // todo: 根据注解生成自定义指令 v-annoName="context"
@@ -3203,22 +3202,12 @@ export class ViewElement extends Annotatable {
           };
           let argsList = aa.arguments.map((arg: any) => getExpressionValue(arg.expression));
           let annoArgs = {
+            annotationName:aa.annotationName,
             argsList,
             dataRefList,
           };
-          // 所有参数序列化之后当字符串传进指令参数 （目前不支持<div v-demo="{ color: 'white', text: 'hello!' }"></div>
-          let expression = StringLiteral.from({
-            concept: 'StringLiteral',
-            kind: 'Expression',
-            name: '',
-            value: JSON.stringify(annoArgs),
-          });
-          let annoDirective = BindDirective.from({
-            name: aa.annotationName,
-            // arg:'arg',
-            expression,
-          });
-          return annoDirective;
+          return annoArgs
+
         });
       }
     };
@@ -3258,9 +3247,8 @@ export class ViewElement extends Annotatable {
                       propName: attr?.expression.toUI()?.replace('current.item.', ''),
                     };
                     dataRefList.push(ref);
-                    // 要考虑 多个元素 每个元素有多个注解的情况
-                    let result = (genDirectiveByAnno(viewElement) as any)?.map((d: any) => d?.toVue());
-                    result && result?.length > 0 && parts.push(...result);
+                    let result = (genDirectiveByAnno(viewElement) as any)
+                    result && result?.length > 0 && preAnnoParts.push(...result);
                   }
                 }
               }
@@ -3309,8 +3297,9 @@ export class ViewElement extends Annotatable {
                 propName: entityPropName,
               };
               dataRefList.push(ref);
-              let result = (genDirectiveByAnno(viewElement) as any)?.map((d: any) => d?.toVue());
-              result && result?.length > 0 && parts.push(...result);
+
+              let result = (genDirectiveByAnno(viewElement) as any)
+              result && result?.length > 0 && preAnnoParts.push(...result);
             }
             // typeName "Entity1"
             // typeNamespace "app.dataSources.defaultDS.entities"
@@ -3337,7 +3326,38 @@ export class ViewElement extends Annotatable {
       // 2 向上是线性布局 卡片 template gridView
     };
     getEntityDataRef(this);
+    let annoMap:any = {}
 
+    preAnnoParts?.map((annoArgs:any)=>{
+      let annotationName =annoArgs.annotationName
+      if(!annoMap[annotationName] ){
+        annoMap[annotationName]  =[]
+      }
+      annoMap[annotationName] = annoArgs
+    })
+    Object.keys(annoMap)?.map(key=>{
+    let annoArgs =annoMap[key]
+      let {
+        annotationName,
+        argsList,
+        dataRefList,
+      }= annoArgs;
+      // 一个元素可以有多个指令； 其中一个指令可以从多处获取参数 这里就不能直接生成指令了 不然多个参数就变成了多个指令 实现同一个指令多个参数
+          // 所有参数序列化之后当字符串传进指令参数 （目前不支持<div v-demo="{ color: 'white', text: 'hello!' }"></div>
+          let expression = StringLiteral.from({
+            concept: 'StringLiteral',
+            kind: 'Expression',
+            name: '',
+            value: JSON.stringify(annoArgs),
+          });
+          let annoDirective = BindDirective.from({
+            name: annotationName,
+            // arg:'arg',
+            expression,
+          });
+      let directString = annoDirective?.toVue()
+      directString && parts.push(directString)
+    })
     if (vIfs.length === 2) parts.push(`v-if="(${vIfs[0]}) && (${vIfs[1]})"`);
     else if (vIfs.length === 1) parts.push(`v-if="${vIfs[0]}"`);
 

package/src/concepts/View__.ts

@@ -46,6 +46,8 @@ const removedViewElementCache: {
   [key: string]: number | bigint;
 } = {};
 
+import { config } from '../config';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1857,7 +1859,7 @@ export class View extends Annotatable {
                 document.addEventListener('keydown', this.onKeyDown);
                 document.addEventListener('keyup', this.onKeyUp);
             },
-            beforeDestory() {
+            beforeDestroy() {
                 document.removeEventListener('keydown', this.onKeyDown);
                 document.removeEventListener('keyup', this.onKeyUp);
             },
@@ -2126,7 +2128,7 @@ export class View extends Annotatable {
         if (item.tag === 'template' && item.haveScope()) {
           index += 1;
         }
-        if (ComponentCompletionPropertyMap[item.tag]) {
+        if (config?.allNodesAPI && config?.allNodesAPI[item.tag]?.readablePropsMap) {
           componentList.push(item);
         }
         item.currentIndex = index;
@@ -2360,22 +2362,39 @@ export class View extends Annotatable {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
               returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },
@@ -3129,15 +3148,17 @@ export class View extends Annotatable {
 
   getSubLogics() {
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
-      if (asserts.isSubLogic(node)) {
-        // 仅仅是为了处理数据源中的子逻辑，Logic 下面的，交由Logic 自己处理
-        if (node?.getAncestor('Logic')) {
-          return false;
-        }
+      // 仅仅是为了处理数据源中的子逻辑，Logic 下面的，交由Logic 自己处理
+      if (node?.concept === 'Logic') {
+        return true;
+      }
+      if (node?.concept === 'SubLogic') {
         return true;
       }
     });
-    this.subLogics = subLogics as Array<SubLogic>;
+    this.subLogics = subLogics?.filter(node => {
+      return asserts.isSubLogic(node);
+    }) as Array<SubLogic>;
   }
 
   existingSubLogic: Set<string> = new Set<string>();

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

@@ -378,6 +378,51 @@ export function initialize() {
         }),
       ],
     }),
+    new Structure({
+      name: 'TaskInst',
+      properties: [
+        new StructureProperty({
+          name: 'processDefUniqueKey',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'processDefinitionId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'processInstanceId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'taskDefName',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'taskTitle',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'completeBy',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'finished',
+          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+        }),
+        new StructureProperty({
+          name: 'createTime',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'completeTime',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+    }),
   );
 
   processV2TypeList.push(
@@ -820,6 +865,24 @@ export function initialize() {
       ],
       returns: [],
     }),
+    new Logic({
+      name: 'getUsersForAddSign',
+      description: '查询可加签用户列表',
+      params: [
+        new Param({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createGeneric('List', {
+            typeArguments: [TypeAnnotation.createReference('LCAPUser', { typeNamespace: 'nasl.processV2' })],
+          }),
+        }),
+      ],
+    }),
     new Logic({
       name: 'terminateProcess',
       description: '终止',
@@ -919,6 +982,22 @@ export function initialize() {
         }),
       ],
     }),
+    new Logic({
+      name: 'getTaskInfo',
+      description: '查询流程任务信息',
+      params: [
+        new Param({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createReference('TaskInst', { typeNamespace: 'nasl.processV2' }),
+        }),
+      ],
+    }),
   ];
 
   const processComponents = [

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

@@ -1012,46 +1012,46 @@ export function initialize() {
     new Structure({
       name: 'KeyboardEvent',
       properties: [
-        // new StructureProperty({
-        //     name: 'altKey',
-        //     description: '事件触发时 alt 键 (OS X 系统上的 Option 或 ⌥ 键) 是 (true) 否 (false) 被按下',
-        //     typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
-        // }),
-        // new StructureProperty({
-        //     name: 'code',
-        //     description: '',
-        //     typeAnnotation: TypeAnnotation.createPrimitive('String')
-        // }),
-        // new StructureProperty({
-        //     name: 'ctrlKey',
-        //     description: '事件触发时 control 键是 (true) 否 (false) 按下',
-        //     typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
-        // }),
-        // new StructureProperty({
-        //     name: 'isComposing',
-        //     description: '该事件是否在 compositionstart 之后和 compositionend 之前被触发',
-        //     typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
-        // }),
-        // new StructureProperty({
-        //     name: 'key',
-        //     description: '',
-        //     typeAnnotation: TypeAnnotation.createPrimitive('String')
-        // }),
-        // new StructureProperty({
-        //     name: 'metaKey',
-        //     description: '指示 Meta 键是按下状态（true），还是释放状态（false）',
-        //     typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
-        // }),
-        // new StructureProperty({
-        //     name: 'repeat',
-        //     description: '如果按键被一直按住，返回值为true',
-        //     typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
-        // }),
-        // new StructureProperty({
-        //     name: 'shiftKey',
-        //     description: '事件触发时 shift 键是 (true) 否 (false) 按下',
-        //     typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
-        // })
+        new StructureProperty({
+            name: 'altKey',
+            description: '事件触发时 alt 键 (OS X 系统上的 Option 或 ⌥ 键) 是 (true) 否 (false) 被按下',
+            typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
+        }),
+        new StructureProperty({
+            name: 'code',
+            description: '',
+            typeAnnotation: TypeAnnotation.createPrimitive('String')
+        }),
+        new StructureProperty({
+            name: 'ctrlKey',
+            description: '事件触发时 control 键是 (true) 否 (false) 按下',
+            typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
+        }),
+        new StructureProperty({
+            name: 'isComposing',
+            description: '该事件是否在 compositionstart 之后和 compositionend 之前被触发',
+            typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
+        }),
+        new StructureProperty({
+            name: 'key',
+            description: '',
+            typeAnnotation: TypeAnnotation.createPrimitive('String')
+        }),
+        new StructureProperty({
+            name: 'metaKey',
+            description: '指示 Meta 键是按下状态（true），还是释放状态（false）',
+            typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
+        }),
+        new StructureProperty({
+            name: 'repeat',
+            description: '如果按键被一直按住，返回值为true',
+            typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
+        }),
+        new StructureProperty({
+            name: 'shiftKey',
+            description: '事件触发时 shift 键是 (true) 否 (false) 按下',
+            typeAnnotation: TypeAnnotation.createPrimitive('Boolean')
+        })
       ],
     }),
   );

package/src/generator/genBundleFiles.ts

@@ -860,7 +860,7 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
         if (window.annotationAllData) {
               resolve(window.annotationAllData);
           } else {
-           let sysPrefixPath =  window.appInfo && window.appInfo.sysPrefixPath || '';
+           let sysPrefixPath =  ${ config?.sysPrefixPath ? "'" + config?.sysPrefixPath + "'" : "'" + "'" } ||'';
            let urlEntity = sysPrefixPath + '/api/system/annotation/entityAll'
            let urlLogic = sysPrefixPath + '/api/system/annotation/logicAll'
            Promise.all([

package/src/generator/release-body/utils.ts

@@ -425,7 +425,7 @@ export function getProcessFormDefinitions(app: App) {
               );
               formDefinition = formDefinition.replaceAll(
                 `(${process.name} ||`,
-                '{processDetailFormData ||'
+                '(processDetailFormData ||'
               );
               formDefinition = formDefinition.replace(
                 /:ref="([^"]+)"/g,

package/src/natural/getContext/index.ts

@@ -191,7 +191,7 @@ export function getEnums(app: App, state: TranslatorState) {
   const namespace = 'app.enums';
   const data = [] as Snippet[];
   app.enums.forEach((enumeration) => {
-    const temp = `${enumeration?.toNaturalTS({ ...state, needNamespace: true })}`;
+    const temp = `${enumeration?.toNaturalTS({ ...state, needNamespace: true, })}`;
     data.push({ description: enumeration?.description || enumeration?.name, code: temp });
   });
   return { namespace, enums: { namespace, data } };
@@ -201,7 +201,7 @@ export const getEnumsCode = (enums: any) => {
   let code = '';
   code += `declare namespace ${enums?.namespace} {\n`;
   enums?.data?.forEach((item: any) => {
-    code += item?.description ? `/* ${item.description} */ \n` : '';
+    // code += item?.description ? `/* ${item.description} */ \n` : '';
     code += `${item.code}\n`;
   });
   code += `}\n`;
@@ -338,6 +338,7 @@ export const getModuleInterfacesCode = (interfaceDependencies: any, codeType: 'd
       if (requiredIndexes?.length && !requiredIndexes?.includes(interfaceIndex)) return;
       if (codeType === 'short') {
         const tempCode = item.code.replace(`${interfaceDependency?.logics.namespace}.`, '');
+        // code += `[${interfaceIndex}] \`${tempCode}\`\n`;
         code += `[${interfaceIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
       } else {
         code += item.codeWithDetail;
@@ -457,7 +458,8 @@ export const getConnectorsCode = (connections: any, codeType: 'detail' | 'short'
       if (codeType === 'short') {
         const namespace = item?.namespace || connection?.logics.namespace;
         const tempCode = item.code.replace(`${namespace}.`, '');
-        code += `[${interfaceIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
+        code += `[${interfaceIndex}] \`${tempCode}\`\n`;
+        // code += `[${interfaceIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
       } else {
         code += item.codeWithDetail;
       }
@@ -527,7 +529,8 @@ export const getDependenciesCode = (dependencies: any, codeType: 'detail' | 'sho
       if (requiredIndexes?.length && !requiredIndexes?.includes(logicIndex)) return;
       if (codeType === 'short') {
         const tempCode = item.code.replace(`${dependency?.logics.namespace}.`, '');
-        code += `[${logicIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
+        code += `[${logicIndex}] \`${tempCode}\`\n`;
+        // code += `[${logicIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
       } else {
         code += item.codeWithDetail;
       }
@@ -632,7 +635,7 @@ export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: s
       function (state) {
         let code = '';
         code += `\n${indent(state.tabSize)}`;
-        
+
         if (experimental) {
           code += this.elements[0].toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
         } else {

package/src/natural/tools.ts

@@ -80,7 +80,9 @@ export const getUnImportedModulesForLogic = (json: BaseNode, app: App, material:
       // 如果 连接器 不存在，则需要导入并初始化连接
       if (!connectorNode) {
         item.operator = 'importAndInit';
-        item.version = material?.connectors?.find((node: any) => node.name === item.symbol)?.version;
+        const curDep = material?.connectors?.find((node: any) => node.name === item.symbol)
+        item.version = curDep?.version;
+        item.provider = curDep?.provider || '资产中心';
         needImportModule.needImportConnector = true;
         needImportModule.connectors.set(item.symbol, item);
       } else {
@@ -104,7 +106,9 @@ export const getUnImportedModulesForLogic = (json: BaseNode, app: App, material:
       item.category = 'library';
       const logicNode = app.dependencies?.find((node: any) => node.name === item.symbol);
       if (!logicNode) {
-        item.version = material?.dependencies?.find((node: any) => node.name === item.symbol)?.version;
+        const curDep = material?.dependencies?.find((node: any) => node.name === item.symbol);
+        item.version = curDep?.version;
+        item.provider = curDep?.provider || '资产中心';
         needImportModule.library.set(item.symbol, item);
       }
     } else if (item.node.concept === 'ViewElement') {
@@ -116,7 +120,9 @@ export const getUnImportedModulesForLogic = (json: BaseNode, app: App, material:
         item.category = 'library';
         item.key = `${libraryName}-${name}`;
         item.symbol = libraryName;
-        item.version = material?.dependencies?.find((node: any) => node.name === libraryName)?.version;
+        const curDep = material?.dependencies?.find((node: any) => node.name === item.symbol);
+        item.version = curDep?.version;
+        item.provider = curDep?.provider || '';
         needImportModule.extensionMaterials.set(name, item);
       }
     }

package/src/natural/transformTS2UI.ts

@@ -976,11 +976,11 @@ function transformNode2Logic(node: babelTypes.FunctionDeclaration, name?: string
   const statements: babelTypes.Statement[] = node.body.body;
 
   const curLogic: any = new naslTypes.Logic({ name: name ?? node.id.name });
-  parameters.forEach((item: babelTypes.Identifier) => {
+  parameters?.forEach((item: babelTypes.Identifier) => {
     const param = transformParam(item);
     if (param && param.name !== 'event' && !curLogic.params.find((_: any) => _.name === param.name)) curLogic.addParam(param);
   });
-  statements.forEach((item) => {
+  statements?.forEach((item) => {
     if (item.type === 'ReturnStatement' && item?.argument) {
       if (!curLogic.returns.length) {
         curLogic.returns.push(new naslTypes.Return({
@@ -1015,6 +1015,7 @@ function transformNode2Logic(node: babelTypes.FunctionDeclaration, name?: string
 
 // 处理属性
 function transformNode2Attribute(node: any): any {
+  if (!node?.value || !node?.key) return {};
   let item = {} as any;
   let newNode = {} as any;
   if (['StringLiteral', 'NumericLiteral'].includes(node.value.type)) {
@@ -1214,14 +1215,16 @@ function transformNode2ViewConstruct(node: babelTypes.Node): naslTypes.ViewEleme
           } else if (properties?.[2].value.value === 'BindAttribute') {
             newNode = transformNode2Attribute({ key: element.left, value: element.right });
           }
-          const newNodeBackup = cloneDeep(newNode);
-          (newNode as any).aiParams = {
-            action: properties?.[0].value.value,
-            selectedNodeName: properties?.[1].value.value,
-            concept: properties?.[2].value.value,
-            object: newNodeBackup
-          };
-          newViewElement.push(newNode);
+          if (newNode) {
+            const newNodeBackup = cloneDeep(newNode);
+            (newNode as any).aiParams = {
+              action: properties?.[0].value.value,
+              selectedNodeName: properties?.[1].value.value,
+              concept: properties?.[2].value.value,
+              object: newNodeBackup
+            };
+            newViewElement.push(newNode);
+          }
         });
       }
     });
@@ -1246,19 +1249,21 @@ function transformNode2View(node: babelTypes.FunctionDeclaration, root?: ParseRe
   }
 
   const view = new naslTypes.View();
-  parameters.forEach((item) => {
+  parameters?.forEach((item) => {
     const param = transformParam(item);
     param && view.params.push(param);
   });
 
   const json: any = [];
-  statements.forEach((item) => {
+  statements?.forEach((item) => {
     const viewItem = transformNode2ViewConstruct(item) as any;
     if (item.type === 'ReturnStatement' && item?.argument?.type === 'CallExpression') {
       const action = (item.argument as any)?.callee?.name;
       const selectedNodeName = (item.argument as any).arguments?.[0]?.property?.name;
-      const newNodeBackup = cloneDeep(viewItem);
-      (viewItem as any).aiParams = { selectedNodeName, action, concept: 'ViewElement', object: newNodeBackup };
+      if (viewItem) {
+        const newNodeBackup = cloneDeep(viewItem);
+        (viewItem as any).aiParams = { selectedNodeName, action, concept: 'ViewElement', object: newNodeBackup };
+      }
     }
     if (item.type === 'ReturnStatement' && item?.argument?.type === 'ArrayExpression') {
       viewItem?.forEach((element: any) => {

package/src/server/getMemberIdentifier.ts

@@ -15,9 +15,9 @@ import {
   types,
   ViewElement,
   PAGE_COMPONENT_INCLUDE_TAG_MAP,
-  ComponentCompletionPropertyMap,
   configurationEnums,
   processV2Enums,
+  config,
 } from '..';
 import { formatVariableData, formatFrontEndVariables, formatConfigProperties, formatBackendVariables } from './formatTsUtils';
 
@@ -422,8 +422,8 @@ export function getConfigsIdentifier(node: BaseNode): CompletionProperty[] {
 }
 function flatElements(elements: ViewElement[], componentList: CompletionProperty[], nodeParentElement: string, currentAttriBute: string, parentNodeNames: string[]) {
   elements?.forEach((item) => {
-    // 根据ComponentCompletionPropertyMap添加
-    if (ComponentCompletionPropertyMap?.[item.tag]) {
+    // 根据readablePropsMap添加
+    if (config?.allNodesAPI[item.tag] && config?.allNodesAPI[item.tag].readablePropsMap) {
       // 是否当前组件
       const isCurrent = item.name === nodeParentElement;
       const stashItem: any = {
@@ -436,9 +436,9 @@ function flatElements(elements: ViewElement[], componentList: CompletionProperty
         children: [],
       }
 
-      for (const key in ComponentCompletionPropertyMap[item.tag]) {
-        if (Object.prototype.hasOwnProperty.call(ComponentCompletionPropertyMap[item.tag], key)) {
-          const property = ComponentCompletionPropertyMap[item.tag][key];
+      for (const key in config?.allNodesAPI[item.tag].readablePropsMap) {
+        if (Object.prototype.hasOwnProperty.call(config?.allNodesAPI[item.tag].readablePropsMap, key)) {
+          const property = config?.allNodesAPI[item.tag].readablePropsMap[key];
 
           // 如果是当前组件，过滤掉当前属性
           if (!isCurrent || currentAttriBute !== property.prop) {
@@ -454,7 +454,7 @@ function flatElements(elements: ViewElement[], componentList: CompletionProperty
               })
             })
 
-            completionProperty.name = `${key}（${property.label}）`;
+            completionProperty.name = `${key}（${property.title}）`;
             completionProperty.icon = property.icon || 'attr'
             stashItem.children.push(completionProperty)
           }
@@ -511,21 +511,21 @@ 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') {
+  } if (item.parentNode?.concept === 'View') {
     return undefined
-  } else {
-    return getCurrentElement(item.parentNode)
   }
+    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
     }
-  }
+      return undefined
+
+
 }