@lcap/nasl 3.8.0-beta.5 → 3.8.0-beta.7

package/src/natural/getContext/index.ts

@@ -1,4 +1,4 @@
-import { App, View, Logic, BaseNode, Frontend, Namespace, Module, TypeAnnotation, Structure, Connection, Connector } from '../../concepts';
+import { App, View, Logic, BaseNode, Frontend, Namespace, Module, TypeAnnotation, Structure } from '../../concepts';
 import { shiftState, createCompilerState, TranslatorState, indent } from '../../translator';
 import { getPreDeclaration, getUILib, handleMaterial, getExtensionsMaterial } from './getUILib';
 import { getNASLStdlibMap } from './naslStdlibMap';
@@ -6,8 +6,6 @@ import { getNASLStdlibMap } from './naslStdlibMap';
 export interface Snippet {
   description: string;
   code: string;
-  codeWithDetail?: string;
-  namespace?: string;
 }
 export interface SnippetBlock {
   namespace: string;
@@ -18,34 +16,8 @@ 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') {
-            const { typeNamespace, typeName } = property?.typeAnnotation || {};
-            relationStructures.push({ typeNamespace, typeName });
-          }
-          if (property?.typeAnnotation?.typeArguments?.length) {
-            property?.typeAnnotation?.typeArguments?.forEach((typeArg: TypeAnnotation) => {
-              if (typeArg.typeKind === 'reference') {
-                const { typeNamespace, typeName } = typeArg || {};
-                relationStructures.push({ typeNamespace, typeName });
-              }
-            });
-          }
-        });
-      });
-  });
-  if (!relationStructures.length) return relationStructures;
-  return [...relationStructures, ...getReferenceStructures(relationStructures, structures)];
-}
-
 // 获取logic用到的数据结构(带属性版)
-export function getLogicWithStructuresCode(logic: Logic, type: string, desc: { description: string; codeStr: string; }, namespace: string) {
+export function getLogicStructures(logic: Logic, type: string, desc: { description: string; codeStr: string; }, namespace: string) {
   const { params, returns } = logic || {};
   if (!params?.length && !returns?.length) return '';
   let code = '';
@@ -68,32 +40,30 @@ export function getLogicWithStructuresCode(logic: Logic, type: string, desc: { d
       });
     }
   });
-
-  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) {
+  if (namespace && referenceStructures?.length) {
     code += `declare namespace ${namespace} {\n`;
   }
 
-  newRelationStructures?.forEach((reference: { typeNamespace: string; typeName: string; }) => {
-    const { typeName } = reference || {};
+  referenceStructures?.forEach((reference: { typeNamespace: string; typeName: string; }) => {
+    const { typeNamespace, typeName } = reference || {};
     const state = createCompilerState();
     const tabSize = namespace ? shiftState(state, code, { tabSize: 1 }) : undefined;
-    structures?.filter((structure: any) => structure?.name === typeName)
-      ?.forEach((structure: any) => {
-        code += `${structure?.toNaturalTS(tabSize)}\n`;
-      });
+    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`;
+        });
+    }
   });
-  if (namespace && newRelationStructures?.length) {
+  if (namespace && referenceStructures?.length) {
     code += `}\n`;
   }
   const { description, codeStr } = desc || {};
@@ -119,60 +89,37 @@ export function getNaslUtil() {
   return { code, naslUtil };
 }
 
-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);
+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);
 
-  return { naslUI };
-};
+  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 getNaslUICode = (naslUI: any, codeType: 'detail' | 'short', requiredIndexes?: string[]) => {
-  let code = '';
   const preDeclaration = getPreDeclaration();
-  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) => `/**
+  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) =>
+        `/**
 * ${item.name}
 * ${item.title}
 * ${item.description}
 */
 ${item.tsDeclaration}`).join('\n')}`);
-  } else {
-    code += uiLib.map((item: any, index: number) => `[3-${index}] ${item.name} | ${item.title} | ${item.description}`).join('\n');
-  }
-  return code;
+  return { code, naslUI };
 };
 
 export const getNaslUIOld = () => {
@@ -187,121 +134,92 @@ export function getNaslOQL() {
   return { code, naslOql };
 }
 
-export function getEnums(app: App, state: TranslatorState) {
+export function getEnums(app: App, state: TranslatorState, requiredIndexes?: string[]) {
+  const needNamespace = requiredIndexes?.length >= 0;
   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: true })}`;
+    const temp = `${enumeration?.toNaturalTS({ ...state, needNamespace })}`;
+    code += temp;
     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;
-};
+  return { code, namespace, enums: { namespace, data } };
+}
 
-export function getEntities(app: App, state: TranslatorState) {
+export function getEntities(app: App, state: TranslatorState, requiredIndexes?: string[]) {
+  const needNamespace = requiredIndexes?.length >= 0;
   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 = `app.dataSources.${dataSource?.name}.entities.${entity?.name}`;
-        const tempCode = `${entity?.toNaturalTS({ ...state, needNamespace: true }, entityName)}`;
+        const entityName = needNamespace ? `app.dataSources.${dataSource?.name}.entities.${entity?.name}` : undefined;
+        const tempCode = `${entity?.toNaturalTS({ ...state, needNamespace }, entityName)}`;
+        code += tempCode;
         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;
-};
+  return { code, entities };
+}
 
-export function getStructures(app: App, state: TranslatorState) {
+export function getStructures(app: App, state: TranslatorState, requiredIndexes?: string[]) {
+  const needNamespace = requiredIndexes?.length >= 0;
   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: true })}`;
+      const tempCode = `${structure?.toNaturalTS({ ...state, needNamespace })}`;
+      code += tempCode;
       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;
-};
-
+  return { code, structures: { namespace, data } };
+}
 
-export function getLogics(app: App, currentNode: BaseNode) {
+export function getLogics(app: App, currentNode: BaseNode, requiredIndexes?: string[]) {
+  const hasModuleIndexList = requiredIndexes?.length > 0;
   const data = [] as Snippet[];
   const namespace = `app.logics`;
+  let code = '';
   app?.logics
     ?.filter((logic) => logic !== currentNode && !logic.name.startsWith('LCAP'))
-    ?.forEach((logic) => {
-      const rename = logic?.calleewholeKey;
-      const tempCode = `${logic?.toNaturalTS({ needNamespace: true, rename, declaration: true })}`;
+    ?.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 })}`;
       const description = logic?.description || '';
-
+      code += `[${logicIndex}] ${description ? `${description}: ` : ''}\`${tempCode}\`\n`;
       data.push({ description, code: tempCode });
     });
-  return { appLogics: { namespace, data } };
+  return { code, appLogics: { namespace, data } };
 }
 
-
-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) {
+export function getModuleInterfaces(app: App, state: TranslatorState, requiredIndexes?: string[]) {
+  const hasModuleIndexList = requiredIndexes?.length > 0;
   const interfaceDependencies = [] as {
     name: string;
     structures: SnippetBlock;
     logics: SnippetBlock;
   }[];
-  modules?.forEach((interfaceDependency) => {
-    interfaceDependency = new Module(interfaceDependency);
-    interfaceDependency.parentKey = 'interfaceDependencies';
+  let code = '';
+  app?.interfaceDependencies?.forEach((interfaceDependency, moduleIndex) => {
     const name = interfaceDependency?.name;
     let structures = {} as SnippetBlock;
     let logics = {} as SnippetBlock;
@@ -316,46 +234,37 @@ export function getModuleInterfaces(modules: Module[], state: TranslatorState) {
 
     const logicNamespace = `${namespace}.interfaces`;
     const logicData = [] as Snippet[];
-    interfaceDependency?.interfaces?.forEach((interface_: any) => {
+    interfaceDependency?.interfaces?.forEach((interface_: any, index) => {
+      const interfaceIndex = `7-${moduleIndex}-${index}`;
+      if (hasModuleIndexList && !requiredIndexes?.includes(interfaceIndex)) return;
       const description = interface_?.description || '';
-      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 });
+      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`;
+      }
     });
     logics = { namespace: logicNamespace, data: logicData };
 
     interfaceDependencies.push({ name, structures, logics });
   });
-  return { interfaceDependencies };
+  return { code, interfaceDependencies };
 }
 
-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) {
+export function getConnectors(app: App, state: TranslatorState, requiredIndexes?: string[]) {
+  const hasModuleIndexList = requiredIndexes?.length > 0;
   const connections = [] as {
     name: string;
     structures: SnippetBlock;
     logics: SnippetBlock;
   }[];
-  modules?.forEach((connection) => {
+  let code = '';
+  app?.connections?.forEach((connection, connectionIndex) => {
     const name = connection?.name;
 
     let structures = {} as SnippetBlock;
@@ -370,172 +279,98 @@ export function getConnections(modules: Connection[], state: TranslatorState) {
     });
     structures = { namespace: structureNamespace, data: structureData };
 
+    code += `[8-${connectionIndex}] ${connection?.connector?.title}\n`;
     const logicData = [] as Snippet[];
-    connection?.connector?.namespaces?.forEach((namespace: Namespace) => {
-      const curNameSpace = `${connectionNamespace}.${namespace?.name}`;
-      namespace?.logics?.forEach((logic: Logic) => {
+    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;
         const description = `${logic?.description || logic?.title || ''}`;
-        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 });
+        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`;
+        }
       });
     });
 
     if (!connection?.connector?.namespaces?.length && connection?.connector?.logics?.length) {
-      connection?.connector?.logics.forEach((logic: Logic) => {
+      connection?.connector?.logics.forEach((logic: Logic, index: number) => {
+        const logicIndex = `8-${connectionIndex}-${index}`;
+        if (hasModuleIndexList && !requiredIndexes?.includes(logicIndex)) return;
         const description = logic?.description || '';
-        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 });
+        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`;
+        }
       });
     }
     logics = { namespace: connectionNamespace, data: logicData };
     connections.push({ name, structures, logics });
   });
-  return { connections };
+  return { code, connections };
 }
 
-// 连接器
-export function getConnectors(modules: Connector[], state: TranslatorState) {
-  const connectors = [] as {
-    name: string;
-    structures: SnippetBlock;
-    logics: SnippetBlock;
-  }[];
-  modules?.forEach((connector) => {
-    connector = new Connector(connector);
-    connector.parentKey = 'connectorDependencies';
-    const { name } = connector;
-    let structures = {} as SnippetBlock;
-    let logics = {} as SnippetBlock;
-
-    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;
-};
-
-
-export function getDependencies(modules: Module[], state: TranslatorState, logicType: any, frontendType: 'pc' | 'h5') {
+export function getDependencies(app: App, state: TranslatorState, requiredIndexes?: string[]) {
+  const hasModuleIndexList = requiredIndexes?.length > 0;
   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;
+  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 };
+
+        dependencies.push({ name, structures, logics });
       }
     });
-  });
-  return code;
-};
-
+  return { code, dependencies };
+}
 
 export function getFrontendVariables(frontend: Frontend, state: TranslatorState) {
   let code = '';
@@ -593,17 +428,7 @@ 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) {
+export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: string, experimental?: boolean) {
   let code = '';
   let view: View;
   if (currentNode?.concept === 'View') {
@@ -631,16 +456,22 @@ export function getCurrentNodeContext(currentNode: BaseNode, focusedNodePath?: s
       }),
       function (state) {
         let code = '';
-        code += `\n${indent(state.tabSize + 1)}const $refs = {\n`;
-        // 生成所有的name和类型定义
-        this.elements.forEach((element) => {
-          code += element.toNaturalTSDefinition(
-            shiftState(state, code, {
-              tabSize: state.tabSize + 1,
-            })
-          );
-        });
-        code += `${indent(state.tabSize + 1)}}\n`;
+        code += `\n${indent(state.tabSize)}`;
+        
+        if (experimental) {
+          code += this.elements[0].toNaturalTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+        } else {
+          code += `const $refs = {\n`;
+          // 生成所有的name和类型定义
+          this.elements.forEach((element) => {
+            code += element.toNaturalTSDefinition(
+              shiftState(state, code, {
+                tabSize: state.tabSize + 1,
+              })
+            );
+          });
+          code += `${indent(state.tabSize + 1)}}\n`;
+        }
         // 逻辑
         if (currentNode?.concept === 'Logic') {
           code += '\n';