@lcap/nasl 3.8.0-beta.6 → 3.8.2-beta.2

package/src/natural/getContext/index.ts

@@ -1,4 +1,4 @@
-import { App, View, Logic, BaseNode, Frontend, Namespace, Module, TypeAnnotation, Structure } from '../../concepts';
+import { App, View, Logic, BaseNode, Frontend, Namespace, Module, TypeAnnotation, Structure, Connection, Connector } from '../../concepts';
 import { shiftState, createCompilerState, TranslatorState, indent } from '../../translator';
 import { getPreDeclaration, getUILib, handleMaterial, getExtensionsMaterial } from './getUILib';
 import { getNASLStdlibMap } from './naslStdlibMap';
@@ -6,6 +6,8 @@ import { getNASLStdlibMap } from './naslStdlibMap';
 export interface Snippet {
   description: string;
   code: string;
+  codeWithDetail?: string;
+  namespace?: string;
 }
 export interface SnippetBlock {
   namespace: string;
@@ -16,8 +18,34 @@ export const wrapTSBlock = (code: string) => {
   return `\`\`\`ts\n${code.trimEnd()}\n\`\`\`\n`;
 };
 
+// 获取有引用的 structures
+export function getReferenceStructures(referenceStructures: { typeNamespace: string; typeName: string; }[], structures: Structure[]): any {
+  const relationStructures = [] as any;
+  referenceStructures?.forEach((reference: { typeNamespace: string; typeName: string; }) => {
+    structures?.filter((structure: any) => structure?.name === reference?.typeName)
+      ?.forEach((structure: any) => {
+        structure.properties?.forEach((property: any) => {
+          if (property?.typeAnnotation?.typeKind === 'reference' && referenceStructures.findIndex((item: any) => item.typeName === property?.typeAnnotation?.typeName) === -1) {
+            const { typeNamespace, typeName } = property?.typeAnnotation || {};
+            relationStructures.push({ typeNamespace, typeName });
+          }
+          if (property?.typeAnnotation?.typeArguments?.length) {
+            property?.typeAnnotation?.typeArguments?.forEach((typeArg: TypeAnnotation) => {
+              if (typeArg.typeKind === 'reference' && referenceStructures.findIndex((item: any) => item.typeName === typeArg.typeName) === -1) {
+                const { typeNamespace, typeName } = typeArg || {};
+                relationStructures.push({ typeNamespace, typeName });
+              }
+            });
+          }
+        });
+      });
+  });
+  if (!relationStructures.length) return relationStructures;
+  return [...relationStructures, ...getReferenceStructures(relationStructures, structures)];
+}
+
 // 获取logic用到的数据结构(带属性版)
-export function getLogicStructures(logic: Logic, type: string, desc: { description: string; codeStr: string; }, namespace: string) {
+export function getLogicWithStructuresCode(logic: Logic, type: string, desc: { description: string; codeStr: string; }, namespace: string) {
   const { params, returns } = logic || {};
   if (!params?.length && !returns?.length) return '';
   let code = '';
@@ -40,30 +68,32 @@ export function getLogicStructures(logic: Logic, type: string, desc: { descripti
       });
     }
   });
-  if (namespace && referenceStructures?.length) {
+
+  let structures = [] as any;
+  if (type === 'connector') {
+    structures = logic?.connector?.structures;
+  } else if (type === 'extension' || type === 'interface') {
+    structures = (logic?.parentNode as Module)?.structures;
+  }
+
+  const relationStructures = getReferenceStructures(referenceStructures, structures);
+
+  const newRelationStructures = [...relationStructures, ...referenceStructures];
+
+  if (namespace && newRelationStructures?.length) {
     code += `declare namespace ${namespace} {\n`;
   }
 
-  referenceStructures?.forEach((reference: { typeNamespace: string; typeName: string; }) => {
-    const { typeNamespace, typeName } = reference || {};
+  newRelationStructures?.forEach((reference: { typeNamespace: string; typeName: string; }) => {
+    const { typeName } = reference || {};
     const state = createCompilerState();
     const tabSize = namespace ? shiftState(state, code, { tabSize: 1 }) : undefined;
-    if (typeNamespace?.includes('extensions.') && type === 'connector') {
-      logic?.connector?.structures
-        ?.filter((structure) => structure?.name === typeName)
-        ?.forEach((structure) => {
-          code += `${structure?.toNaturalTS(tabSize)}\n`;
-        });
-    }
-    if ((typeNamespace?.includes('extensions.') && type === 'extension') || (typeNamespace?.includes('apis.') && type === 'interface')) {
-      (logic?.parentNode as Module)?.structures
-        ?.filter((structure) => structure?.name === typeName)
-        ?.forEach((structure) => {
-          code += `${structure?.toNaturalTS(tabSize)}\n`;
-        });
-    }
+    structures?.filter((structure: any) => structure?.name === typeName)
+      ?.forEach((structure: any) => {
+        code += `${structure?.toNaturalTS(tabSize)}\n`;
+      });
   });
-  if (namespace && referenceStructures?.length) {
+  if (namespace && newRelationStructures?.length) {
     code += `}\n`;
   }
   const { description, codeStr } = desc || {};
@@ -89,37 +119,60 @@ export function getNaslUtil() {
   return { code, naslUtil };
 }
 
-export const getNaslUI = (app: App, frontendType: 'pc' | 'h5', material: { basicMaterials: { json: any; tsDeclaration: string; }, extensionMaterials: { name: string; title: string; description: string; tsDescription: string; }[]; } | string, requiredIndexes?: string[]) => {
-  const hasModuleIndexList = requiredIndexes?.length > 0;
-  const uiLib = typeof material === 'string' ? getUILib(material as 'pc' | 'h5') : handleMaterial(material.basicMaterials);
-  const extensionMaterials = typeof material === 'string' ? getExtensionsMaterial(app, frontendType) : material.extensionMaterials || [];
-  uiLib.push(...extensionMaterials);
-
-  if (!hasModuleIndexList) {
-    const naslUI = uiLib;
-    const code = naslUI.map((item, index) => `[3-${index}] ${item.name} | ${item.title} | ${item.description}`).join('\n');
-    return { code, naslUI };
+export const getNaslUI = (
+  app: App,
+  frontendType: 'pc' | 'h5',
+  material:
+    {
+      basicMaterials: 'pc' | 'h5' | { json: any; tsDeclaration: string; };
+      extensionMaterials: {
+        name: string;
+        title: string;
+        description: string;
+        tsDescription: string;
+      }[];
+    },
+) => {
+  let naslUI = [] as any;
+  if (material.basicMaterials) {
+    naslUI = typeof material.basicMaterials === 'string' ? getUILib(material.basicMaterials as 'pc' | 'h5') : handleMaterial(material.basicMaterials);
   }
 
+  const extensionMaterials = typeof material.extensionMaterials === 'string' ? getExtensionsMaterial(app, frontendType) : material.extensionMaterials || [];
+  naslUI.push(...extensionMaterials);
+
+  return { naslUI };
+};
+
+export const getNaslUICode = (naslUI: any, codeType: 'detail' | 'short', requiredIndexes?: string[]) => {
+  let code = '';
   const preDeclaration = getPreDeclaration();
-  const naslUI = uiLib.filter(
-    (item, index) =>
-      requiredIndexes.includes(`3-${index}`) ||
-      item.name.endsWith('LinearLayout') ||
-      item.name.endsWith('Text') ||
-      item.name.endsWith('Link') ||
-      item.name.endsWith('Button')
-  );
-  const code = wrapTSBlock(
-    `${preDeclaration}\n${naslUI.map(
-      (item) =>
-        `/**
+  let uiLib = naslUI;
+  if (requiredIndexes?.length) {
+    // 过滤出需要的组件
+    uiLib = naslUI.filter(
+      (item: any, index: number) =>
+        requiredIndexes.includes(`3-${index}`) ||
+        item.name.endsWith('LinearLayout') ||
+        item.name.endsWith('Text') ||
+        item.name.endsWith('Link') ||
+        item.name.endsWith('Button')
+    );
+  }
+  if (codeType === 'detail') {
+    code = wrapTSBlock(
+      `${preDeclaration}\n${uiLib
+        .map(
+          (item: any) => `/**
 * ${item.name}
 * ${item.title}
 * ${item.description}
 */
 ${item.tsDeclaration}`).join('\n')}`);
-  return { code, naslUI };
+  } else {
+    code += uiLib.map((item: any, index: number) => `[3-${index}] ${item.name} | ${item.title} | ${item.description}`).join('\n');
+  }
+  return code;
 };
 
 export const getNaslUIOld = () => {
@@ -134,92 +187,121 @@ export function getNaslOQL() {
   return { code, naslOql };
 }
 
-export function getEnums(app: App, state: TranslatorState, requiredIndexes?: string[]) {
-  const needNamespace = requiredIndexes?.length >= 0;
+export function getEnums(app: App, state: TranslatorState) {
   const namespace = 'app.enums';
   const data = [] as Snippet[];
-  let code = '';
-  code += `declare namespace ${namespace} {\n`;
   app.enums.forEach((enumeration) => {
-    const temp = `${enumeration?.toNaturalTS({ ...state, needNamespace })}`;
-    code += temp;
+    const temp = `${enumeration?.toNaturalTS({ ...state, needNamespace: true })}`;
     data.push({ description: enumeration?.description || enumeration?.name, code: temp });
   });
+  return { namespace, enums: { namespace, data } };
+}
+
+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.code}\n`;
+  });
   code += `}\n`;
   code = wrapTSBlock(code);
-  return { code, namespace, enums: { namespace, data } };
-}
+  return code;
+};
 
-export function getEntities(app: App, state: TranslatorState, requiredIndexes?: string[]) {
-  const needNamespace = requiredIndexes?.length >= 0;
+export function getEntities(app: App, state: TranslatorState) {
   const entities = [] as SnippetBlock[];
-  let code = '';
   app.dataSources.forEach((dataSource) => {
     const data = [] as Snippet[];
     const namespace = `app.dataSources.${dataSource?.name}.entities`;
-    code += `declare namespace ${namespace} {\n`;
     dataSource.entities
       .filter((entity) => !entity.name.startsWith('LCAP') || entity.name === 'LCAPUser')
       .forEach((entity) => {
-        const entityName = needNamespace ? `app.dataSources.${dataSource?.name}.entities.${entity?.name}` : undefined;
-        const tempCode = `${entity?.toNaturalTS({ ...state, needNamespace }, entityName)}`;
-        code += tempCode;
+        const entityName = `app.dataSources.${dataSource?.name}.entities.${entity?.name}`;
+        const tempCode = `${entity?.toNaturalTS({ ...state, needNamespace: true }, entityName)}`;
         data.push({ description: entity?.description || entity?.name, code: tempCode });
       });
     entities.push({ namespace, data });
+  });
+  return { entities };
+}
+
+export const getEntitiesCode = (entities: any) => {
+  let code = '';
+  entities?.forEach((entity: any) => {
+    code += `declare namespace ${entity?.namespace} {\n`;
+    entity?.data?.forEach((item: any) => {
+      code += item?.description ? `/* ${item.description} */ \n` : '';
+      code += `${item.code}\n`;
+    });
     code += `}\n`;
   });
   code = wrapTSBlock(code);
-  return { code, entities };
-}
+  return code;
+};
 
-export function getStructures(app: App, state: TranslatorState, requiredIndexes?: string[]) {
-  const needNamespace = requiredIndexes?.length >= 0;
+export function getStructures(app: App, state: TranslatorState) {
   const data = [] as Snippet[];
   const namespace = `app.structures`;
-  let code = '';
-  code += `declare namespace ${namespace} {\n`;
   app.structures
     .filter((entity) => !entity.name.startsWith('LCAP'))
     .forEach((structure) => {
-      const tempCode = `${structure?.toNaturalTS({ ...state, needNamespace })}`;
-      code += tempCode;
+      const tempCode = `${structure?.toNaturalTS({ ...state, needNamespace: true })}`;
       data.push({ description: structure?.description || structure?.name, code: tempCode });
     });
+  return { structures: { namespace, data } };
+}
+
+export const getStructuresCode = (structures: any) => {
+  let code = '';
+  code += `declare namespace ${structures?.namespace} {\n`;
+  structures?.data?.forEach((item: any) => {
+    code += item?.description ? `/* ${item.description} */ \n` : '';
+    code += `${item.code}\n`;
+  });
   code += `}\n`;
   code = wrapTSBlock(code);
-  return { code, structures: { namespace, data } };
-}
+  return code;
+};
+
 
-export function getLogics(app: App, currentNode: BaseNode, requiredIndexes?: string[]) {
-  const hasModuleIndexList = requiredIndexes?.length > 0;
+export function getLogics(app: App, currentNode: BaseNode) {
   const data = [] as Snippet[];
   const namespace = `app.logics`;
-  let code = '';
   app?.logics
     ?.filter((logic) => logic !== currentNode && !logic.name.startsWith('LCAP'))
-    ?.forEach((logic, index) => {
-      const logicIndex = `6-${index}`;
-      if (hasModuleIndexList && !requiredIndexes?.includes(logicIndex)) return;
-      const rename = requiredIndexes?.length >= 0 ? logic?.calleewholeKey : undefined;
-      const needNamespace = requiredIndexes?.length >= 0;
-      const tempCode = `${logic?.toNaturalTS({ needNamespace, rename, declaration: true })}`;
+    ?.forEach((logic) => {
+      const rename = logic?.calleewholeKey;
+      const tempCode = `${logic?.toNaturalTS({ needNamespace: true, rename, declaration: true })}`;
       const description = logic?.description || '';
-      code += `[${logicIndex}] ${description ? `${description}: ` : ''}\`${tempCode}\`\n`;
+
       data.push({ description, code: tempCode });
     });
-  return { code, appLogics: { namespace, data } };
+  return { appLogics: { namespace, data } };
 }
 
-export function getModuleInterfaces(app: App, state: TranslatorState, requiredIndexes?: string[]) {
-  const hasModuleIndexList = requiredIndexes?.length > 0;
+
+export const getLogicsCode = (appLogics: any, codeType: 'detail' | 'short', requiredIndexes?: string[]) => {
+  let code = '';
+  appLogics?.data?.forEach((item: any, index: number) => {
+    const logicIndex = `6-${index}`;
+    if (requiredIndexes?.length && !requiredIndexes?.includes(logicIndex)) return;
+    const tempCode = codeType === 'short' ? item.code.replace(`${appLogics.namespace}.`, '') : item.code;
+    code += `[${logicIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
+  });
+  return code;
+};
+
+
+export function getModuleInterfaces(modules: Module[], state: TranslatorState) {
   const interfaceDependencies = [] as {
     name: string;
     structures: SnippetBlock;
     logics: SnippetBlock;
   }[];
-  let code = '';
-  app?.interfaceDependencies?.forEach((interfaceDependency, moduleIndex) => {
+  modules?.forEach((interfaceDependency) => {
+    interfaceDependency = new Module(interfaceDependency);
+    interfaceDependency.parentKey = 'interfaceDependencies';
     const name = interfaceDependency?.name;
     let structures = {} as SnippetBlock;
     let logics = {} as SnippetBlock;
@@ -234,37 +316,46 @@ export function getModuleInterfaces(app: App, state: TranslatorState, requiredIn
 
     const logicNamespace = `${namespace}.interfaces`;
     const logicData = [] as Snippet[];
-    interfaceDependency?.interfaces?.forEach((interface_: any, index) => {
-      const interfaceIndex = `7-${moduleIndex}-${index}`;
-      if (hasModuleIndexList && !requiredIndexes?.includes(interfaceIndex)) return;
+    interfaceDependency?.interfaces?.forEach((interface_: any) => {
       const description = interface_?.description || '';
-      const interfaceName = requiredIndexes?.length >= 0 ? interface_?.calleewholeKey : undefined;
-      const needNamespace = requiredIndexes?.length >= 0;
-      const tempCode = interface_?.toNaturalTS(createCompilerState('', { needNamespace }), interfaceName);
-      logicData.push({ description, code: tempCode });
-
-      if (requiredIndexes?.includes(interfaceIndex)) {
-        code += getLogicStructures(interface_, 'interface', { description, codeStr: tempCode }, structureNamespace);
-      } else {
-        code += `[${interfaceIndex}] ${description ? `${description}: ` : ''}\`${tempCode}\`\n`;
-      }
+      const interfaceName = interface_?.calleewholeKey;
+      const tempCode = interface_?.toNaturalTS(createCompilerState('', { needNamespace: true }), interfaceName);
+      const codeWithDetail = getLogicWithStructuresCode(interface_, 'interface', { description, codeStr: tempCode }, structureNamespace);
+      logicData.push({ description, code: tempCode, codeWithDetail });
     });
     logics = { namespace: logicNamespace, data: logicData };
 
     interfaceDependencies.push({ name, structures, logics });
   });
-  return { code, interfaceDependencies };
+  return { interfaceDependencies };
 }
 
-export function getConnectors(app: App, state: TranslatorState, requiredIndexes?: string[]) {
-  const hasModuleIndexList = requiredIndexes?.length > 0;
+export const getModuleInterfacesCode = (interfaceDependencies: any, codeType: 'detail' | 'short', requiredIndexes?: string[]) => {
+  let code = '';
+  interfaceDependencies.forEach((interfaceDependency: any, index: number) => {
+    interfaceDependency?.logics?.data?.forEach((item: any, idx: number) => {
+      const interfaceIndex = `7-${index}-${idx}`;
+      if (requiredIndexes?.length && !requiredIndexes?.includes(interfaceIndex)) return;
+      if (codeType === 'short') {
+        const tempCode = item.code.replace(`${interfaceDependency?.logics.namespace}.`, '');
+        code += `[${interfaceIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
+      } else {
+        code += item.codeWithDetail;
+      }
+    });
+  });
+  return code;
+};
+
+
+// 连接
+export function getConnections(modules: Connection[], state: TranslatorState) {
   const connections = [] as {
     name: string;
     structures: SnippetBlock;
     logics: SnippetBlock;
   }[];
-  let code = '';
-  app?.connections?.forEach((connection, connectionIndex) => {
+  modules?.forEach((connection) => {
     const name = connection?.name;
 
     let structures = {} as SnippetBlock;
@@ -279,99 +370,173 @@ export function getConnectors(app: App, state: TranslatorState, requiredIndexes?
     });
     structures = { namespace: structureNamespace, data: structureData };
 
-    code += `[8-${connectionIndex}] ${connection?.connector?.title}\n`;
     const logicData = [] as Snippet[];
-    connection?.connector?.namespaces?.forEach((namespace: Namespace, namespaceIndex: number) => {
-      namespace?.logics?.forEach((logic: Logic, index) => {
-        const logicIndex = `8-${connectionIndex}-${namespaceIndex}-${index}`;
-        if (hasModuleIndexList && !requiredIndexes?.includes(logicIndex)) return;
+    connection?.connector?.namespaces?.forEach((namespace: Namespace) => {
+      const curNameSpace = `${connectionNamespace}.${namespace?.name}`;
+      namespace?.logics?.forEach((logic: Logic) => {
         const description = `${logic?.description || logic?.title || ''}`;
-        const rename = requiredIndexes?.length >= 0 ? `${connection?.name}.${logic?.calleewholeKey}` : undefined;
-        const needNamespace = requiredIndexes?.length >= 0;
-        const tempCode = `${logic?.toNaturalTS(shiftState(state, code, { needNamespace, rename, declaration: true }))}`;
-        logicData.push({ description, code: tempCode });
-
-        if (requiredIndexes?.includes(logicIndex)) {
-          code += getLogicStructures(logic, 'connector', { description, codeStr: tempCode }, structureNamespace);
-        } else {
-          code += `[${logicIndex}] ${description ? `${description}: ` : ''}\`${tempCode}\`\n`;
-        }
+        const rename = `${connection?.name}.${logic?.calleewholeKey}`;
+        const tempCode = `${logic?.toNaturalTS(shiftState(state, '', { needNamespace: true, rename, declaration: true }))}`;
+        const codeWithDetail = getLogicWithStructuresCode(logic, 'connector', { description, codeStr: tempCode }, structureNamespace);
+        logicData.push({ description, code: tempCode, codeWithDetail, namespace: curNameSpace });
       });
     });
 
     if (!connection?.connector?.namespaces?.length && connection?.connector?.logics?.length) {
-      connection?.connector?.logics.forEach((logic: Logic, index: number) => {
-        const logicIndex = `8-${connectionIndex}-${index}`;
-        if (hasModuleIndexList && !requiredIndexes?.includes(logicIndex)) return;
+      connection?.connector?.logics.forEach((logic: Logic) => {
         const description = logic?.description || '';
-        const rename = requiredIndexes?.length >= 0 ? `${connection?.name}.${logic?.calleewholeKey}` : undefined;
-        const needNamespace = requiredIndexes?.length >= 0;
-        const tempCode = `${logic?.toNaturalTS(shiftState(state, code, { needNamespace, rename, declaration: true }))}`;
-        logicData.push({ description, code: tempCode });
-
-        if (requiredIndexes?.includes(logicIndex)) {
-          code += getLogicStructures(logic, 'connector', { description, codeStr: tempCode }, structureNamespace);
-        } else {
-          code += `[${logicIndex}] ${description ? `${description}: ` : ''}\`${tempCode}\`\n`;
-        }
+        const rename = `${connection?.name}.${logic?.calleewholeKey}`;
+        const tempCode = `${logic?.toNaturalTS(shiftState(state, '', { needNamespace: true, rename, declaration: true }))}`;
+        const codeWithDetail = getLogicWithStructuresCode(logic, 'connector', { description, codeStr: tempCode }, structureNamespace);
+        logicData.push({ description, code: tempCode, codeWithDetail });
       });
     }
     logics = { namespace: connectionNamespace, data: logicData };
     connections.push({ name, structures, logics });
   });
-  return { code, connections };
+  return { connections };
 }
 
-export function getDependencies(app: App, state: TranslatorState, requiredIndexes?: string[]) {
-  const hasModuleIndexList = requiredIndexes?.length > 0;
-  const dependencies = [] as {
+// 连接器
+export function getConnectors(modules: Connector[], state: TranslatorState) {
+  const connectors = [] as {
     name: string;
     structures: SnippetBlock;
     logics: SnippetBlock;
   }[];
-  let code = '';
-  app?.dependencies
-    ?.filter((dependency) => dependency.concept === 'Module')
-    ?.forEach((module, moduleIndex) => {
-      // 区分一下扩展组件和依赖库
-      if (module?.logics?.length) {
-        const name = module?.name;
-        let structures = {} as SnippetBlock;
-        let logics = {} as SnippetBlock;
-        const namespace = `extensions.${name}`;
-        const structureNamespace = `${namespace}.structures`;
-        const structureData = [] as Snippet[];
-        module?.structures?.forEach((structure) => {
-          const tempCode = `${structure?.toNaturalTS({ ...state, needNamespace: true })}`;
-          structureData.push({ description: structure?.description || structure?.name, code: tempCode });
-        });
-        structures = { namespace: structureNamespace, data: structureData };
-
-        const logicsNamespace = `${namespace}.logics`;
-        const logicData = [] as Snippet[];
-        module?.logics?.forEach((logic, index) => {
-          const logicIndex = `9-${moduleIndex}-${index}`;
-          if (hasModuleIndexList && !requiredIndexes?.includes(logicIndex)) return;
-          const description = logic?.description || '';
-          const rename = requiredIndexes?.length >= 0 ? logic?.calleewholeKey : undefined;
-          const needNamespace = requiredIndexes?.length >= 0;
-          const tempCode = `${logic?.toNaturalTS(shiftState(state, code, { needNamespace, rename, declaration: true }))}`;
-          logicData.push({ description, code: tempCode });
-
-          if (requiredIndexes?.includes(logicIndex)) {
-            code += getLogicStructures(logic, 'extension', { description, codeStr: tempCode }, structureNamespace);
-          } else {
-            code += `[${logicIndex}] ${description ? `${description}: ` : ''}\`${tempCode}\`\n`;
-          }
-        });
-        logics = { namespace: logicsNamespace, data: logicData };
+  modules?.forEach((connector) => {
+    connector = new Connector(connector);
+    connector.parentKey = 'connectorDependencies';
+    const { name } = connector;
+    let structures = {} as SnippetBlock;
+    let logics = {} as SnippetBlock;
 
-        dependencies.push({ name, structures, logics });
+    const connectorNamespace = `${name}.connector.${name}`;
+    const structureNamespace = `connector.${name}.structures`;
+    const structureData = [] as Snippet[];
+    connector?.structures?.forEach((structure: Structure) => {
+      const tempCode = `${structure?.toNaturalTS({ ...state, needNamespace: true })}`;
+      structureData.push({ description: structure?.description || structure?.name, code: tempCode });
+    });
+    structures = { namespace: structureNamespace, data: structureData };
+
+    const logicData = [] as Snippet[];
+    connector?.namespaces?.forEach((namespace: Namespace) => {
+      const curNameSpace = `${connectorNamespace}.${namespace?.name}`;
+      namespace?.logics?.forEach((logic: Logic) => {
+        const description = `${logic?.description || logic?.title || ''}`;
+        const rename = `${name}.${logic?.calleewholeKey}`;
+        const tempCode = `${logic?.toNaturalTS(shiftState(state, '', { needNamespace: true, rename, declaration: true }))}`;
+        const codeWithDetail = getLogicWithStructuresCode(logic, 'connector', { description, codeStr: tempCode }, structureNamespace);
+        logicData.push({ description, code: tempCode, codeWithDetail, namespace: curNameSpace });
+      });
+    });
+
+    if (!connector?.namespaces?.length && connector?.logics?.length) {
+      connector?.logics.forEach((logic: Logic) => {
+        const description = logic?.description || '';
+        const rename = `${name}.${logic?.calleewholeKey}`;
+        const tempCode = `${logic?.toNaturalTS(shiftState(state, '', { needNamespace: true, rename, declaration: true }))}`;
+        const codeWithDetail = getLogicWithStructuresCode(logic, 'connector', { description, codeStr: tempCode }, structureNamespace);
+        logicData.push({ description, code: tempCode, codeWithDetail });
+      });
+    }
+    logics = { namespace: connectorNamespace, data: logicData };
+    connectors.push({ name, structures, logics });
+  });
+
+  return { connectors };
+}
+
+export const getConnectorsCode = (connections: any, codeType: 'detail' | 'short', requiredIndexes?: string[]) => {
+  let code = '';
+  connections.forEach((connection: any, index: number) => {
+    connection?.logics?.data?.forEach((item: any, idx: number) => {
+      const interfaceIndex = `8-${index}-${idx}`;
+      if (requiredIndexes?.length && !requiredIndexes?.includes(interfaceIndex)) return;
+      if (codeType === 'short') {
+        const namespace = item?.namespace || connection?.logics.namespace;
+        const tempCode = item.code.replace(`${namespace}.`, '');
+        code += `[${interfaceIndex}] ${item.description ? `${item.description}: ` : ''}\`${tempCode}\`\n`;
+      } else {
+        code += item.codeWithDetail;
       }
     });
-  return { code, dependencies };
+  });
+  return code;
+};
+
+
+export function getDependencies(modules: Module[], state: TranslatorState, logicType: any, frontendType: 'pc' | 'h5') {
+  const dependencies = [] as {
+    name: string;
+    structures: SnippetBlock;
+    logics: SnippetBlock;
+  }[];
+  modules?.forEach((module) => {
+    module = new Module(module);
+    module.parentKey = 'dependencies';
+    // 根据类型获取对应的逻辑
+    let curLogics = module?.logics;
+    if (logicType !== 'global_logic' && frontendType) {
+      module?.frontends?.forEach((frontend: any) => {
+        if (frontend.type === frontendType) {
+          curLogics = curLogics.concat([...frontend?.logics]);
+        }
+      });
+    }
+
+    if (curLogics?.length) {
+      const name = module?.name;
+      let structures = {} as SnippetBlock;
+      let logics = {} as SnippetBlock;
+      const namespace = `extensions.${name}`;
+      const structureNamespace = `${namespace}.structures`;
+      const structureData = [] as Snippet[];
+      module?.structures?.forEach((structure) => {
+        const tempCode = structure?.toNaturalTS ? `${structure?.toNaturalTS({ ...state, needNamespace: true })}` : '';
+        structureData.push({ description: structure?.description || structure?.name, code: tempCode });
+      });
+      structures = { namespace: structureNamespace, data: structureData };
+
+      let logicsNamespace = '';
+      const logicData = [] as Snippet[];
+      curLogics?.forEach((logic) => {
+        const description = logic?.description || '';
+        const rename = logic?.calleewholeKey;
+        logicsNamespace = logic?.calleewholeKey.replace(`.${logic.name}`, '');
+        const tempCode = `${logic?.toNaturalTS(shiftState(state, '', { needNamespace: true, rename, declaration: true }))}`;
+        const codeWithDetail = getLogicWithStructuresCode(logic, 'extension', { description, codeStr: tempCode }, structureNamespace);
+
+        logicData.push({ description, code: tempCode, codeWithDetail });
+      });
+      logics = { namespace: logicsNamespace, data: logicData };
+
+      dependencies.push({ name, structures, logics });
+    }
+  });
+  return { dependencies };
 }
 
+
+export const getDependenciesCode = (dependencies: any, codeType: 'detail' | 'short', requiredIndexes?: string[]) => {
+  let code = '';
+  dependencies.forEach((dependency: any, index: number) => {
+    dependency?.logics?.data?.forEach((item: any, idx: number) => {
+      const logicIndex = `9-${index}-${idx}`;
+      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`;
+      } else {
+        code += item.codeWithDetail;
+      }
+    });
+  });
+  return code;
+};
+
+
 export function getFrontendVariables(frontend: Frontend, state: TranslatorState) {
   let code = '';
   frontend?.variables?.forEach((variable) => {
@@ -428,6 +593,16 @@ export function getFrontendViews(frontend: Frontend, state: TranslatorState, cur
   return { code: wrapTSBlock(code), views: { namespace, data } };
 }
 
+export const getFrontendViewsCode = (views: any) => {
+  let code = '';
+  views?.data?.forEach((item: any) => {
+    code += `/* ${item.description} */ \n`;
+    code += item.code;
+    code += `\n`;
+  });
+  return wrapTSBlock(code);
+};
+
 export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: string) {
   let code = '';
   let view: View;