@lcap/nasl-unified-frontend-generator 4.1.0-beta.2 → 4.1.0-beta.20

package/dist/index.mjs

@@ -103,11 +103,11 @@ import axios2 from "axios";
 import { trimStart } from "lodash";
 
 // src/default-container.ts
-import { Container as Container20 } from "inversify";
+import { Container as Container21 } from "inversify";
 
 // src/plugins/vue/vue3/vue3-preset-plugin.ts
 import "@abraham/reflection";
-import { inject as inject15, injectable as injectable30 } from "inversify";
+import { inject as inject15, injectable as injectable31 } from "inversify";
 
 // src/service-metakind.ts
 var ServiceMetaKind = {
@@ -1483,6 +1483,7 @@ import {
   isUnparsed,
   isValidationRule,
   isVariable,
+  isVariadicExpression,
   isWhileStatement
 } from "@lcap/nasl-concepts/asserts";
 import { transfromMetadataType, transformUnionTypeAnnotation } from "@lcap/nasl-concepts/service";
@@ -2672,6 +2673,9 @@ query: {`;
         s2.right,
         callbackBag
       )}`;
+    } else if (isVariadicExpression(s2)) {
+      const expressions = s2.expressions.map((exp) => getRuntimeStr(exp, callbackBag));
+      return expressions.join(s2.operator);
     } else if (isMatchCase(s2)) {
       const p = s2.parentNode;
       if (!isMatch(p)) {
@@ -3882,12 +3886,13 @@ function getReactComponentName(c) {
   return c.component.tag;
 }
 var ReactCodegenPlugin = class {
-  constructor(javaScriptCodegen, reactStateManager, frontendPerformance, projectOrganizer, entrypointManager, reactHookProviders) {
+  constructor(javaScriptCodegen, reactStateManager, frontendPerformance, projectOrganizer, entrypointManager, rspackConfigPlugin, reactHookProviders) {
     this.javaScriptCodegen = javaScriptCodegen;
     this.reactStateManager = reactStateManager;
     this.frontendPerformance = frontendPerformance;
     this.projectOrganizer = projectOrganizer;
     this.entrypointManager = entrypointManager;
+    this.rspackConfigPlugin = rspackConfigPlugin;
     this.reactHookProviders = reactHookProviders;
   }
   genReactFragment(c, ctx) {
@@ -4212,7 +4217,7 @@ var ReactCodegenPlugin = class {
     const exts = packages.filter((x) => x.kind === "extension");
     const imports = exts.map((ext) => {
       return {
-        from: `@extension/${ext.name}`,
+        from: `${ext.name}`,
         import: `* as ${kebab2Pascal(ext.name)}`
       };
     }).filter(isNotNil);
@@ -4241,7 +4246,8 @@ var ReactCodegenPlugin = class {
    * @param baseDir - 基目录
    * @returns 组织后的文件列表
    */
-  async genFiles(ir, baseDir) {
+  async genFiles(ir, instruction) {
+    const { baseDir, app, frontend, config, fs } = instruction;
     const utilHooks = ReactFileDescription.empty("Hooks").merge(new ReactFileDescription("", [{ from: "./init" }], [], [])).merge(reactRouterPlugin.functions.__hooksDefinitions()).merge(apiClientPlugin.functions.__hooksDefinitions()).merge(reactComponentLibHackPlugin.functions.__hooksDefinitions()).merge(i18nPlugin.functions.__hooksDefinitions()).merge(this.buildLibraryHook(ir.packages)).merge(new ReactFileDescription("", [], [], [`export {nasl, genInitFromSchema};`]));
     this.reactHookProviders?.forEach((reactHookProvider) => {
       utilHooks.merge(reactHookProvider.genHookDefinition());
@@ -4261,6 +4267,13 @@ var ReactCodegenPlugin = class {
       ir.configs.globalVariables,
       ir.baseCtx
     );
+    const bundlerConfigFile = await this.rspackConfigPlugin.configBundlerConfig({
+      app,
+      frontend,
+      config,
+      fs,
+      frameworkKind: "react"
+    });
     const files = await this.projectOrganizer.organize({
       baseDir,
       project: {
@@ -4273,7 +4286,8 @@ var ReactCodegenPlugin = class {
         platformConfig: this.buildPlatformConfig(ir),
         init: this.buildInit(ir),
         masterCss,
-        globalVariables
+        globalVariables,
+        bundlerConfigFile
       }
     });
     return files;
@@ -4286,8 +4300,9 @@ ReactCodegenPlugin = __decorateClass([
   __decorateParam(2, inject(ServiceMetaKind.FrontendPerformance)),
   __decorateParam(3, inject(ServiceMetaKind.ProjectOrganizer)),
   __decorateParam(4, inject(ServiceMetaKind.EntryPointManager)),
-  __decorateParam(5, multiInject(ServiceMetaKind.ReactHookProvider)),
-  __decorateParam(5, optional())
+  __decorateParam(5, inject(ServiceMetaKind.FrontendBundlerFileConfig)),
+  __decorateParam(6, multiInject(ServiceMetaKind.ReactHookProvider)),
+  __decorateParam(6, optional())
 ], ReactCodegenPlugin);
 function createImportIrFromReferencedComponent(c) {
   switch (c.kind) {
@@ -4419,40 +4434,40 @@ var metadataPlugin = makePlugin({
 // src/hack/material-config/material.config.js
 var materials = {
   framework: {
-    version: "2.0.1",
+    version: "2.1.0",
     core: "@lcap/basic-template",
     pc: [
       {
         frameworkKind: "vue2",
         name: "@lcap/pc-template",
-        version: "2.0.1"
+        version: "2.1.0"
       },
       {
         frameworkKind: "react",
         name: "@lcap/pc-template-react",
-        version: "2.0.1"
+        version: "2.1.0"
       },
       {
         frameworkKind: "vue3",
         name: "@lcap/pc-template-vue3",
-        version: "2.0.1"
+        version: "2.1.0"
       }
     ],
     h5: [
       {
         frameworkKind: "vue2",
         name: "@lcap/mobile-template",
-        version: "2.0.1"
+        version: "2.1.0"
       },
       {
         frameworkKind: "react",
         name: "@lcap/mobile-template-react",
-        version: "2.0.1"
+        version: "2.1.0"
       },
       {
         frameworkKind: "vue3",
         name: "@lcap/mobile-template-vue3",
-        version: "2.0.1"
+        version: "2.1.0"
       }
     ]
   },
@@ -4503,7 +4518,7 @@ var materials = {
         frameworkVersion: "vue@3.5.13",
         name: "@lcap/vant",
         libName: "LcapVant",
-        version: "1.0.0-beta.1"
+        version: "1.0.0"
       }
     ]
   },
@@ -4841,7 +4856,7 @@ function getReferencedLibComponent(e) {
     if (tag === "Router") {
       return { kind: "library", libraryName: "react-router-dom", tag: "Outlet" };
     }
-    const libraryName = foundExtension ? `@extension/${foundExtension.name}` : DefaultComponentLibraryName;
+    const libraryName = foundExtension ? `${foundExtension.name}` : DefaultComponentLibraryName;
     return { kind: "library", libraryName, tag };
   } else if (tag) {
     return { kind: "library", libraryName: DefaultComponentLibraryName, tag };
@@ -5531,14 +5546,14 @@ var NASLAppIRBuilderPlugin = class {
   }
   enchanceHackForAppPackageInfos(app, commonAppConfig) {
     app.loadPackageInfos(getPredefinedMaterialConfig());
-    const config = getConfig();
-    if (commonAppConfig.allNodesAPI) {
-      config.allNodesAPI = commonAppConfig.allNodesAPI;
-    }
-    config.allNodesAPI ??= {};
+    const naslStoreConfig = getConfig();
+    naslStoreConfig.allNodesAPI = commonAppConfig.allNodesAPI || {};
     initialize({
       getConfig: () => {
-        return config;
+        return {
+          ...commonAppConfig || {},
+          ...naslStoreConfig || {}
+        };
       }
     });
   }
@@ -5984,6 +5999,9 @@ var ProjectOrganizerPlugin = class {
         const to = f.getFolder().replace(originalBizComponentsFolderMark, "/components/");
         f.moveFileTo(to);
         l2.debug(`${f.originalAbsolutePath} -> ${f.currentAbsolutePath}`);
+      } else if (/(rspack|vite).config.(j|t)s$/.test(f.originalAbsolutePath)) {
+        f.moveFileTo("/");
+        l2.debug(`${f.originalAbsolutePath} -> ${f.currentAbsolutePath}`);
       }
     }
   }
@@ -6820,10 +6838,10 @@ function normalizeStaticUrl(staticURL) {
   return ensureUrlHasProtocol(staticURL.replace(/^\/\//, ""));
 }
 function getPublicPath(app, config, frontend) {
+  let publicPath = `${getBasePath(app, config)}${frontend.basePath ?? ""}`;
   if (config.isExport) {
-    return `/`;
+    publicPath = frontend.prefixPath || `/`;
   }
-  const publicPath = `${getBasePath(app, config)}${frontend.basePath ?? ""}`;
   if (publicPath.endsWith("/")) {
     return publicPath;
   }
@@ -7040,6 +7058,7 @@ async function downloadDependenciesToLcapModules(feDeps, fs, config) {
     downloadedDeps.forEach(({ pkgName, targetPath }) => {
       packageJson.lcap_modules[pkgName] = `.${targetPath}`;
     });
+    packageJson = setApplicationName(packageJson, config.app?.name || config.app?.id);
     fs.write("/package.json", JSON.stringify(packageJson, null, 2));
     logger13.info("\u4E0B\u8F7D\u524D\u7AEF\u4F9D\u8D56\u5E93\u5230 lcap_modules \u76EE\u5F55\u5B8C\u6210");
   } catch (error) {
@@ -7048,6 +7067,12 @@ async function downloadDependenciesToLcapModules(feDeps, fs, config) {
     }
   }
 }
+function setApplicationName(packageJson, appName = Date.now().toString()) {
+  if (packageJson && appName) {
+    packageJson.name = appName;
+  }
+  return packageJson;
+}
 
 // src/plugins/misc/bundler/bundler-config-data-plugin.ts
 var logger11 = Logger("BundlerConfigDataPlugin");
@@ -7059,7 +7084,8 @@ var BundlerConfigDataPlugin = class {
     const feDeps = [...extractAppLevelFrontendDeps(app), ...extractFrontendLevelDeps(frontend)];
     await downloadDependenciesToLcapModules(feDeps, fs, {
       STATIC_URL: config.STATIC_URL,
-      frameworkKind
+      frameworkKind,
+      app
     });
     const orginDependencies = await downloadDependenciesToPackages(feDeps, fs, {
       STATIC_URL: config.STATIC_URL
@@ -7069,13 +7095,12 @@ var BundlerConfigDataPlugin = class {
       if (target) {
         return {
           name: dep.name,
-          resolvedTo: `./src/${target}`.replace(/\/index\.js$/, ""),
-          scope: dep.kind === "extension" ? "@extension" : void 0
+          resolvedTo: `./src/${target}`.replace(/\/index\.js$/, "")
         };
       }
       return void 0;
     }).filter(isNotNil).map((x) => {
-      const name = x.scope ? `${x.scope}/${x.name}` : x.name;
+      const name = x.name;
       return {
         pkgName: name,
         ...x
@@ -7094,7 +7119,7 @@ var BundlerConfigDataPlugin = class {
     const backendUrl = getBackendPath(app, config, logger11);
     logger11.info(
       { publicPath, backendUrl, aliasMapStr },
-      frameworkKind === "vue3" ? "vite\u914D\u7F6E" : "rspack\u914D\u7F6E"
+      "bundler\u914D\u7F6E"
     );
     this.frontendBundlerConfigPlugin.setCompilerConfig({
       backendUrl,
@@ -7121,7 +7146,8 @@ var RspackConfigPlugin = class {
     this.bundlerConfigDataPlugin = bundlerConfigDataPlugin;
     this.frontendPerformancePlugin = frontendPerformancePlugin;
   }
-  async configBundlerConfig(app, frontend, config, fs, frameworkKind) {
+  async configBundlerConfig(instruction) {
+    const { app, frontend, config, fs, frameworkKind } = instruction;
     const { backendUrl, publicPath, aliasMapStr, dependenciesStr } = await this.bundlerConfigDataPlugin.getBundlerConfigData(
       app,
       frontend,
@@ -7138,17 +7164,42 @@ var RspackConfigPlugin = class {
         );
       }
       rspackConfigSource = rspackConfigSource.replace(`const backendUrl = '';`, `const backendUrl = '${backendUrl}'`).replace(`const publicPath = '';`, `const publicPath = '${publicPath}';`).replace(`sourceMap: false,`, `sourceMap: ${config.env === "dev"},`).replace("alias: {}", `alias: {${aliasMapStr}}`).replace("const isDev = false", `const isDev = ${config.env === "dev"}`);
-      if (config.needCompileViews && config.needCompileViews.length > 0 && config.cacheChunksMapCode) {
+      if (!config.isExport && config.env === "dev" && config.needCompileViews && config.needCompileViews.length > 0 && config.cacheChunksMapCode) {
         rspackConfigSource = rspackConfigSource.replace("isIncremental: false", "isIncremental: true").replace("chunksMap: ''", `chunksMap: \`${config.cacheChunksMapCode}\``);
       }
-      if (config.isExport) {
-        rspackConfigSource = rspackConfigSource.replace(/\/\/ LcapPlugin start\s+new LcapPlugin\(\{[\s\S]*?\}\),\s+\/\/ LcapPlugin end/g, "");
-      }
-      fs.write(
-        "/rspack.config.js",
-        rspackConfigSource
-      );
+      rspackConfigSource = await this.processLoadOnDemand(rspackConfigSource, {
+        app,
+        frontend,
+        config,
+        fs,
+        frameworkKind
+      });
+    }
+    return new ReactFileDescription("rspack.config.js", [], [], [rspackConfigSource || ""]);
+  }
+  /**
+   * 处理按需加载
+   * 注意：此功能仅在非dev环境下的vue3框架中可以启用。
+   * @param source 源代码
+   * @param options 选项
+   * @returns 处理后的代码
+   */
+  async processLoadOnDemand(source, options) {
+    let code = source;
+    const { app, frontend, config, fs, frameworkKind } = options;
+    const { env, feLoadDependenciesOnDemand, isExport } = config;
+    const enablePerformance = feLoadDependenciesOnDemand && (isExport || env !== "dev") && ["vue3"].includes(frameworkKind);
+    if (enablePerformance) {
+      const feDeps = [...extractAppLevelFrontendDeps(app), ...extractFrontendLevelDeps(frontend)];
+      code = code.replaceAll("// swc plugin placeholder", `experimental: {
+        plugins: [
+          ['@lcap/swc-plugin-import', require('./scripts/generateSwcImportPluginConfig')([
+            ${feDeps.map((dep) => "'" + dep.name + "'").join(",\n")}
+          ])]
+        ]
+      }`);
     }
+    return code;
   }
   static install(c) {
     c.bind(ServiceMetaKind.FrontendBundlerFileConfig).to(RspackConfigPlugin).inSingletonScope();
@@ -7177,7 +7228,7 @@ var ReactPresetPlugin = class {
       const frontend = app.findNodeByPath(instruction.frontend.nodePath);
       const ir = this.irBuilder.buildIR(app, frontend, instruction.config);
       const entryScript = this.microFrontendManager.produceScript(ir);
-      const files = await this.reactCodeGenerator.genFiles(ir, instruction.baseDir);
+      const files = await this.reactCodeGenerator.genFiles(ir, instruction);
       const isDebug = instruction.config.debug;
       const finalizedFiles = [
         ...files,
@@ -7558,10 +7609,16 @@ var Vue3LibrariesBuilderPlugin = class {
     const exportArr = [];
     const standardLib = ir.packages.find((x) => x.kind === "standard");
     if (standardLib) {
-      const formattedName = kebab2Pascal(standardLib.name.split("/").at(-1));
-      importArr.push(`import * as ${formattedName} from '${standardLib.name}';`);
-      exportArr.push(`export { ${formattedName} };`);
-      exportArr.push(`window.lcapStandardUI = ${formattedName};`);
+      importArr.push(`import { ConfigProvider, transformKeys, Message, install } from '${standardLib.name}';`);
+      exportArr.push(`export const LcapStandardUI = window.lcapStandardUI = {
+        ConfigProvider,
+        transformKeys,
+        Message,
+        install: (app) => {
+          install(app);
+          app.config.globalProperties.$message = Message;
+        },
+      };`);
       const isPackageZipExists = await judgePackageZipExists(standardLib, config.STATIC_URL);
       importArr.push(
         `import '${standardLib.name}${isPackageZipExists ? "/dist-theme" : ""}/index.css';`
@@ -7569,18 +7626,31 @@ var Vue3LibrariesBuilderPlugin = class {
     }
     const extensions = ir.packages.filter((x) => x.kind === "extension");
     for (const ext of extensions) {
-      const formattedName = kebab2Pascal(ext.name.split("/").at(-1));
       const isPackageZipExists = await judgePackageZipExists(ext, config.STATIC_URL);
-      const prefix = isPackageZipExists ? "" : "@extension/";
-      exportArr.push(`export * as ${formattedName} from '${prefix}${ext.name}';`);
-      if (ext.hasCss) {
+      const { feLoadDependenciesOnDemand } = config;
+      if (!feLoadDependenciesOnDemand && ext.used) {
+        const formattedName = kebab2Pascal(ext.name.split("/").at(-1));
+        importArr.push(`import { install as ${formattedName}Install } from '${ext.name}';`);
+        exportArr.push(`export const ${formattedName} = {
+          install: ${formattedName}Install || (() => {}),
+        };`);
+      }
+      if (ext.used && ext.hasCss) {
         importArr.push(
-          `import '${prefix}${ext.name}${isPackageZipExists ? "/dist-theme" : ""}/index.css';`
+          `import '${ext.name}${isPackageZipExists ? "/dist-theme" : ""}/index.css';`
         );
       }
     }
     return new ReactFileDescription("libraries.ts", [], [], [[...importArr, ...exportArr].join("\n")]);
   }
+  findPackageByNameFromAllNodesAPI(name, allNodesAPI = {}) {
+    for (const key in allNodesAPI) {
+      if (allNodesAPI[key]?.package?.name === name) {
+        return allNodesAPI[key].package;
+      }
+    }
+    return void 0;
+  }
   static install(c) {
     c.bind(Vue3LibrariesBuilderPlugin).toSelf();
     return c;
@@ -7795,7 +7865,7 @@ ComponentPathManager = __decorateClass([
   injectable29()
 ], ComponentPathManager);
 var Vue3ApplicationAssemblerPlugin = class {
-  constructor(vue3CodegenPlugin, routesExtactor, routerBuilder, entryBuilder, librariesBuilder, entryCssBuilder, componentsIndexBuilder, clientLazyloadTemplateBuilder, platformBuilder, metaDataBuilder) {
+  constructor(vue3CodegenPlugin, routesExtactor, routerBuilder, entryBuilder, librariesBuilder, entryCssBuilder, componentsIndexBuilder, clientLazyloadTemplateBuilder, platformBuilder, metaDataBuilder, rspackConfigPlugin) {
     this.vue3CodegenPlugin = vue3CodegenPlugin;
     this.routesExtactor = routesExtactor;
     this.routerBuilder = routerBuilder;
@@ -7806,8 +7876,10 @@ var Vue3ApplicationAssemblerPlugin = class {
     this.clientLazyloadTemplateBuilder = clientLazyloadTemplateBuilder;
     this.platformBuilder = platformBuilder;
     this.metaDataBuilder = metaDataBuilder;
+    this.rspackConfigPlugin = rspackConfigPlugin;
   }
-  async assemble(ir, config) {
+  async assemble(ir, instruction) {
+    const { config, fs, app, frontend } = instruction;
     const manager = new ComponentPathManager();
     const views = ir.views.flatMap((x) => {
       return this.vue3CodegenPlugin.genFiles(x, manager);
@@ -7828,6 +7900,13 @@ var Vue3ApplicationAssemblerPlugin = class {
     });
     const routerFile = new ReactFileDescription("router.ts", router.imports, [], [router.code]);
     const libraries = await this.librariesBuilder.buildLibrariesImport(ir, config);
+    const bundlerConfigFile = await this.rspackConfigPlugin.configBundlerConfig({
+      app,
+      frontend,
+      config,
+      fs,
+      frameworkKind: "vue3"
+    });
     return {
       views,
       bizComponents,
@@ -7838,7 +7917,8 @@ var Vue3ApplicationAssemblerPlugin = class {
       clientLazyloadTemplate: this.clientLazyloadTemplateBuilder.buildClientLazyloadTemplate(ir),
       componentsIndex: this.componentsIndexBuilder.buildComponentsIndex(ir),
       libraries,
-      entryCss: this.entryCssBuilder.buildLibrariesImport(ir)
+      entryCss: this.entryCssBuilder.buildLibrariesImport(ir),
+      bundlerConfig: bundlerConfigFile
     };
   }
   static install(container) {
@@ -7858,9 +7938,185 @@ Vue3ApplicationAssemblerPlugin = __decorateClass([
   __decorateParam(6, inject14(Vue3ComponentsIndexBuilderPlugin)),
   __decorateParam(7, inject14(Vue3ClientLazyloadTemplateBuilderPlugin)),
   __decorateParam(8, inject14(Vue3PlatformBuilderPlugin)),
-  __decorateParam(9, inject14(Vue3MetaDataBuilderPlugin))
+  __decorateParam(9, inject14(Vue3MetaDataBuilderPlugin)),
+  __decorateParam(10, inject14(ServiceMetaKind.FrontendBundlerFileConfig))
 ], Vue3ApplicationAssemblerPlugin);
 
+// src/plugins/misc/program-analysis/analyzer-manager-plugin.ts
+import { injectable as injectable30 } from "inversify";
+
+// src/plugins/misc/program-analysis/analysis/async-analysis.ts
+function buildAsyncAnalyzer() {
+  const resultCache = /* @__PURE__ */ new WeakMap();
+  function isSubtreeAsync(node, analyzeFunc = analyze) {
+    let hasAsync = false;
+    node.traverseStrictChildrenWithPruning((n) => {
+      if (n === node) {
+        return false;
+      }
+      if (hasAsync) {
+        return true;
+      } else if (n) {
+        hasAsync = analyzeFunc(n);
+        return hasAsync;
+      }
+    });
+    return hasAsync;
+  }
+  function analyze(node) {
+    if (!node) {
+      return false;
+    }
+    if (resultCache.has(node)) {
+      return resultCache.get(node);
+    }
+    function dispatch(node2) {
+      switch (node2.concept) {
+        case "CallLogic": {
+          const calleeNode = node2.getCallNode();
+          return analyze(calleeNode) || isSubtreeAsync(node2);
+        }
+        case "CallInterface": {
+          return true;
+        }
+        case "CallFunction": {
+          return isSubtreeAsync(node2);
+        }
+        case "Match": {
+          return isSubtreeAsync(node2);
+        }
+        case "Function": {
+          return isSubtreeAsync(node2);
+        }
+        case "JSBlock": {
+          return true;
+        }
+        case "ExternalDestination":
+        case "Destination": {
+          return true;
+        }
+        case "NewStructure":
+        case "NewComposite":
+        case "NewMap":
+        case "NewList": {
+          return isSubtreeAsync(node2);
+        }
+        case "SubLogic": {
+          return true;
+        }
+        case "Logic": {
+          if (node2.likeComponent) {
+            return node2.subLogics?.some(analyze) || isSubtreeAsync(node2);
+          } else {
+            return true;
+          }
+        }
+        case "AnonymousFunction": {
+          return isSubtreeAsync(node2);
+        }
+        case "BindEvent": {
+          return node2.logics?.some(analyze) ?? false;
+        }
+        case "Interface":
+        case "OverriddenLogic": {
+          return true;
+        }
+        default: {
+          return isSubtreeAsync(node2);
+        }
+      }
+    }
+    resultCache.set(node, true);
+    const res = dispatch(node);
+    resultCache.set(node, res);
+    return res;
+  }
+  return {
+    query: (node) => {
+      return { async: analyze(node) };
+    }
+  };
+}
+
+// src/plugins/misc/program-analysis/analysis/dep-analysis.ts
+import { analyzeDepRef } from "@lcap/nasl-concepts";
+function analyzeDeps(ir, config) {
+  const { views, bizComponents, packages } = ir;
+  const deps = {};
+  views.forEach((view) => {
+    const { libs } = analyzeDepRef(view.__raw, config);
+    for (const key in libs) {
+      deps[key] = deps[key] || [];
+      libs[key].forEach((importer) => {
+        if (!deps[key].some((d) => d.key === importer.key)) {
+          deps[key].push(importer);
+        }
+      });
+    }
+  });
+  bizComponents.forEach((component) => {
+    const { libs } = analyzeDepRef(component.__raw, config);
+    for (const key in libs) {
+      deps[key] = deps[key] || [];
+      libs[key].forEach((importer) => {
+        if (!deps[key].some((d) => d.key === importer.key)) {
+          deps[key].push(importer);
+        }
+      });
+    }
+  });
+  packages.forEach((pkg) => {
+    if (deps[pkg.name]) {
+      pkg.used = true;
+    }
+  });
+}
+
+// src/plugins/misc/program-analysis/analyzer-manager-plugin.ts
+var AnalyzerManagerPlugin = class {
+  constructor() {
+    this.options = {
+      depAnalysis: true
+    };
+  }
+  preProcess(app, frontend, config) {
+    const analyzer = buildAsyncAnalyzer();
+    if (this.getOptions().asyncAnalysis) {
+      app.analyzer = analyzer;
+    }
+    return { app, frontend, config };
+  }
+  postProcess(ir, config) {
+    if (this.getOptions().depAnalysis) {
+      analyzeDeps(ir, config);
+    }
+    return ir;
+  }
+  /**
+   * 设置完整的分析选项
+   * @param options
+   */
+  setOptions(options) {
+    this.options = options;
+  }
+  /**
+   * 获取分析选项
+   * @returns 分析选项
+   */
+  getOptions() {
+    return this.options;
+  }
+  static install(c) {
+    c.bind(ServiceMetaKind.IRPreProcesser).to(AnalyzerManagerPlugin);
+    c.bind(ServiceMetaKind.IRPostProcesser).to(AnalyzerManagerPlugin);
+    c.bind(ServiceMetaKind.AnalyzerManager).to(AnalyzerManagerPlugin);
+    return c;
+  }
+};
+AnalyzerManagerPlugin = __decorateClass([
+  injectable30()
+], AnalyzerManagerPlugin);
+
 // src/plugins/vue/vue3/vue3-preset-plugin.ts
 var logger12 = Logger("Vue3PresetPlugin");
 var Vue3PresetPlugin = class {
@@ -7901,7 +8157,7 @@ var Vue3PresetPlugin = class {
         });
         ir.bizComponents = [];
       }
-      const assembledApplication = await this.applicationAssembler.assemble(ir, instruction.config);
+      const assembledApplication = await this.applicationAssembler.assemble(ir, instruction);
       const finalizedFiles = await this.projectOrganizer.organize({
         baseDir: instruction.baseDir,
         project: assembledApplication,
@@ -7936,6 +8192,7 @@ var Vue3PresetPlugin = class {
     c = VueRouterPlugin.install(c);
     c.bind(ServiceMetaKind.ProjectOrganizer).to(ProjectOrganizerPlugin);
     c.bind(ServiceMetaKind.FileSystemProvider).to(FileSystemPlugin).inSingletonScope();
+    c = AnalyzerManagerPlugin.install(c);
     c = BundlerConfigDataPlugin.install(c);
     c = RspackConfigPlugin.install(c);
     c = FrontendBundlerConfigPlugin.install(c);
@@ -7954,7 +8211,7 @@ var Vue3PresetPlugin = class {
   }
 };
 Vue3PresetPlugin = __decorateClass([
-  injectable30(),
+  injectable31(),
   __decorateParam(0, inject15(ServiceMetaKind.IRBuilder)),
   __decorateParam(1, inject15(ServiceMetaKind.FileSystemProvider)),
   __decorateParam(2, inject15(NpmPackageJSONManagerPlugin)),
@@ -7965,9 +8222,9 @@ Vue3PresetPlugin = __decorateClass([
 // src/default-container.ts
 function makeDefaultContainer(kind = "react") {
   if (kind === "react") {
-    return ReactPresetPlugin.install(new Container20());
+    return ReactPresetPlugin.install(new Container21());
   } else if (kind === "vue3") {
-    return Vue3PresetPlugin.install(new Container20());
+    return Vue3PresetPlugin.install(new Container21());
   } else {
     throw new Error(`\u672A\u5B9E\u73B0${kind}\u7684\u9ED8\u8BA4\u5BB9\u5668`);
   }
@@ -8014,18 +8271,9 @@ async function translateNASLToApp(app, frontend, config, baseDir = "./out", cont
         app,
         frontend,
         config,
-        baseDir
+        baseDir,
+        fs
       });
-      const frontendBundlerFileConfig = container.get(
-        ServiceMetaKind.FrontendBundlerFileConfig
-      );
-      await frontendBundlerFileConfig.configBundlerConfig(
-        app,
-        frontend,
-        config,
-        fs,
-        frontend.frameworkKind
-      );
       if (container.isBound(ServiceMetaKind.CodeGenerationLifecycleHooks)) {
         const hooks = container.getAll(
           ServiceMetaKind.CodeGenerationLifecycleHooks
@@ -8104,7 +8352,11 @@ async function compileAsProject(app, frontend, config, container) {
       logger13.info("\u8FDC\u7A0B\u52A0\u8F7D\u6A21\u677F\u6210\u529F");
       const files = res.files;
       Object.entries(files).forEach(([k, v]) => {
-        fs.write(k, v.code);
+        if (typeof v.code === "string") {
+          fs.write(k, v.code);
+        } else if (v.code?.type === "Buffer") {
+          fs.write(k, Buffer.from(v.code.data));
+        }
       });
     } catch (error) {
       throw new Error(`\u8FDC\u7A0B\u52A0\u8F7D\u6A21\u677F\u5931\u8D25`);
@@ -8163,137 +8415,6 @@ async function compileNASLToReactDist(app, frontend, config, http) {
   }
 }
 
-// src/plugins/misc/program-analysis/analyzer-manager-plugin.ts
-import { injectable as injectable31 } from "inversify";
-
-// src/plugins/misc/program-analysis/analysis/async-analysis.ts
-function buildAsyncAnalyzer() {
-  const resultCache = /* @__PURE__ */ new WeakMap();
-  function isSubtreeAsync(node, analyzeFunc = analyze) {
-    let hasAsync = false;
-    node.traverseStrictChildrenWithPruning((n) => {
-      if (n === node) {
-        return false;
-      }
-      if (hasAsync) {
-        return true;
-      } else if (n) {
-        hasAsync = analyzeFunc(n);
-        return hasAsync;
-      }
-    });
-    return hasAsync;
-  }
-  function analyze(node) {
-    if (!node) {
-      return false;
-    }
-    if (resultCache.has(node)) {
-      return resultCache.get(node);
-    }
-    function dispatch(node2) {
-      switch (node2.concept) {
-        case "CallLogic": {
-          const calleeNode = node2.getCallNode();
-          return analyze(calleeNode) || isSubtreeAsync(node2);
-        }
-        case "CallInterface": {
-          return true;
-        }
-        case "CallFunction": {
-          return isSubtreeAsync(node2);
-        }
-        case "Match": {
-          return isSubtreeAsync(node2);
-        }
-        case "Function": {
-          return isSubtreeAsync(node2);
-        }
-        case "JSBlock": {
-          return true;
-        }
-        case "ExternalDestination":
-        case "Destination": {
-          return true;
-        }
-        case "NewStructure":
-        case "NewComposite":
-        case "NewMap":
-        case "NewList": {
-          return isSubtreeAsync(node2);
-        }
-        case "SubLogic": {
-          return true;
-        }
-        case "Logic": {
-          if (node2.likeComponent) {
-            return node2.subLogics?.some(analyze) || isSubtreeAsync(node2);
-          } else {
-            return true;
-          }
-        }
-        case "AnonymousFunction": {
-          return isSubtreeAsync(node2);
-        }
-        case "BindEvent": {
-          return node2.logics?.some(analyze) ?? false;
-        }
-        case "Interface":
-        case "OverriddenLogic": {
-          return true;
-        }
-        default: {
-          return isSubtreeAsync(node2);
-        }
-      }
-    }
-    resultCache.set(node, true);
-    const res = dispatch(node);
-    resultCache.set(node, res);
-    return res;
-  }
-  return {
-    query: (node) => {
-      return { async: analyze(node) };
-    }
-  };
-}
-
-// src/plugins/misc/program-analysis/analyzer-manager-plugin.ts
-var AnalyzerManagerPlugin = class {
-  constructor() {
-    this.options = {};
-  }
-  preProcess(app, frontend, config) {
-    const analyzer = buildAsyncAnalyzer();
-    if (this.getOptions().asyncAnalysis) {
-      app.analyzer = analyzer;
-    }
-    return { app, frontend, config };
-  }
-  /**
-   * 设置完整的分析选项
-   * @param options
-   */
-  setOptions(options) {
-    this.options = options;
-  }
-  /**
-   * 获取分析选项
-   * @returns 分析选项
-   */
-  getOptions() {
-    return this.options;
-  }
-  static install(c) {
-    c.bind(ServiceMetaKind.IRPreProcesser).to(AnalyzerManagerPlugin);
-    c.bind(ServiceMetaKind.AnalyzerManager).to(AnalyzerManagerPlugin);
-  }
-};
-AnalyzerManagerPlugin = __decorateClass([
-  injectable31()
-], AnalyzerManagerPlugin);
-
 // src/plugins/misc/name-mangler/name-mangler-manager-plugin.ts
 import { injectable as injectable32 } from "inversify";