@aiot-toolkit/aiotpack 2.0.6-beta.9 → 2.1.0-prender.2

package/lib/compiler/javascript/ViteCompiler.d.ts

@@ -0,0 +1,13 @@
+import IJavascriptCompileOption from './interface/IJavascriptCompileOption';
+import ICompileParam from '../interface/ICompileParam';
+import ICompiler from '../interface/ICompiler';
+import { ILog } from '@aiot-toolkit/shared-utils';
+import { IFileLaneContext } from 'file-lane';
+declare class ViteCompiler implements ICompiler {
+    private readonly context;
+    private readonly onLog?;
+    constructor(context: IFileLaneContext, onLog?: ((log: ILog[]) => void) | undefined);
+    compile(param: IJavascriptCompileOption): Promise<void>;
+    clean(param: ICompileParam & IJavascriptCompileOption): Promise<void>;
+}
+export default ViteCompiler;

package/lib/compiler/javascript/ViteCompiler.js

@@ -0,0 +1,449 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _TemplateCompiler = require("./TemplateCompiler");
+var _path = _interopRequireDefault(require("path"));
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+var _UxCompileUtil = _interopRequireDefault(require("./vela/utils/UxCompileUtil"));
+var _UxFileUtils = _interopRequireDefault(require("../../utils/ux/UxFileUtils"));
+var _UxLoaderUtils = _interopRequireDefault(require("../../utils/ux/UxLoaderUtils"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ViteCompiler {
+  constructor(context, onLog) {
+    this.context = context;
+    this.onLog = onLog;
+  }
+  async compile(param) {
+    await this.clean(param);
+    const {
+      projectPath,
+      sourceRoot,
+      outputPath
+    } = param;
+    const originalProjectPath = projectPath.replace(/\.temp_/, '');
+    const buildPath = _path.default.resolve(projectPath, outputPath);
+    const srcPath = _path.default.resolve(originalProjectPath, sourceRoot);
+    const manifestPath = _UxFileUtils.default.getManifestFilePath(originalProjectPath, sourceRoot);
+    const manifest = _fsExtra.default.readJSONSync(manifestPath);
+    const entries = _UxCompileUtil.default.resolveEntries(manifest, srcPath, originalProjectPath);
+    for (const [entryName, entryValue] of Object.entries(entries)) {
+      const entryPath = entryValue.split('?')[0];
+      const resolvedEntry = _path.default.resolve(originalProjectPath, entryPath);
+      if (!_fsExtra.default.existsSync(resolvedEntry)) continue;
+      const outputFile = _path.default.join(buildPath, `${entryName}.js`);
+      _fsExtra.default.ensureDirSync(_path.default.dirname(outputFile));
+      const allEntryPaths = Object.values(entries).map(v => _path.default.resolve(originalProjectPath, v.split('?')[0]));
+      const compilation = {
+        entries: allEntryPaths
+      };
+      try {
+        const {
+          build
+        } = await import('vite');
+        const result = await build({
+          root: originalProjectPath,
+          logLevel: 'silent',
+          resolve: {
+            extensions: ['.js', '.ts', '.ux', '.json']
+          },
+          build: {
+            write: false,
+            lib: {
+              entry: resolvedEntry,
+              formats: ['es'],
+              fileName: () => 'output.js'
+            },
+            rollupOptions: {
+              external: id => id.startsWith('@app-module/') || /^@(system|service|android|hap)\./.test(id),
+              output: {
+                globals: id => `$app_require$("@app-module/${id.replace(/^@(system|service|android|hap|app-module)\./, '')}")`
+              }
+            },
+            commonjsOptions: {
+              transformMixedEsModules: true
+            },
+            minify: param.mode === 'production' ? 'terser' : false,
+            terserOptions: {
+              format: {
+                comments: false
+              }
+            }
+          },
+          plugins: [{
+            name: "cjs-shim",
+            enforce: "pre",
+            load(id) {
+              if (id.includes('node_modules') && !id.endsWith('.ux')) {
+                const content = _fsExtra.default.readFileSync(id, 'utf-8');
+                if (content.includes('module.exports') || content.includes('exports.')) {
+                  return `var module = {exports:{}}; var exports = module.exports;\n${content}\nexport default module.exports;`;
+                }
+              }
+              return null;
+            }
+          }, {
+            name: 'system-to-app-require',
+            enforce: 'pre',
+            transform(code, id) {
+              if (!/@(system|service|android|hap)\.|@app-module\//.test(code)) return null;
+              const NS = '(system|service|android|hap)';
+              let t = code;
+              t = t.replace(new RegExp(`import\\s+(\\w+)\\s+from\\s+['"]@${NS}\\.([^'"]+)['"]\\s*;?`, 'g'), 'const $1 = $app_require$("@app-module/$2.$3");');
+              t = t.replace(new RegExp(`import\\s+\\{([^}]+)\\}\\s+from\\s+['"]@${NS}\\.([^'"]+)['"]\\s*;?`, 'g'), 'const {$1} = $app_require$("@app-module/$2.$3");');
+              t = t.replace(/import\s+(\w+)\s+from\s+['"]@app-module\/([^'"]+)['"]\s*;?/g, 'const $1 = $app_require$("@app-module/$2");');
+              t = t.replace(/import\s+\{([^}]+)\}\s+from\s+['"]@app-module\/([^'"]+)['"]\s*;?/g, 'const {$1} = $app_require$("@app-module/$2");');
+              t = t.replace(/import\s+['"]@app-module\/([^'"]+)['"]\s*;?/g, '$app_require$("@app-module/$1");');
+              t = t.replace(new RegExp(`import\\s+['"]@${NS}\\.([^'"]+)['"]\\s*;?`, 'g'), '$app_require$("@app-module/$1.$2");');
+              return t !== code ? {
+                code: t,
+                map: null
+              } : null;
+            }
+          }, {
+            name: 'ux-loader',
+            resolveId(source, importer) {
+              if (source.endsWith('.ux')) {
+                return importer ? _path.default.resolve(_path.default.dirname(importer), source) : source;
+              }
+            },
+            async load(id) {
+              if (!id.endsWith('.ux')) return null;
+              const content = _fsExtra.default.readFileSync(id, 'utf-8');
+              const isApp = id.endsWith('/app.ux') && _path.default.basename(_path.default.dirname(id)) === 'src';
+              // Generate template.json and css.json
+              if (id === resolvedEntry) {
+                const parse5 = require("aiot-parse5");
+                const doc = parse5.parseFragment(content, {
+                  scriptingEnabled: false
+                });
+                let templateNode = null;
+                const importMap = {}; // name -> path
+                for (const node of doc.childNodes) {
+                  if (node.nodeName === 'template') templateNode = node;else if (node.nodeName === 'import') {
+                    const nameAttr = node.attrs?.find(a => a.name === 'name');
+                    const srcAttr = node.attrs?.find(a => a.name === 'src');
+                    if (nameAttr && srcAttr) {
+                      const compAbsPath = _path.default.resolve(_path.default.dirname(resolvedEntry), srcAttr.value).replace(/\.ux$/, '');
+                      const compPath = _path.default.relative(srcPath, compAbsPath).replace(/\\/g, '/');
+                      importMap[nameAttr.value.toLowerCase()] = compPath;
+                    }
+                  }
+                }
+                const pageName = _path.default.relative(srcPath, id).replace(/\.ux$/, '');
+                // Compute styleObjectId
+                const sid = (0, _TemplateCompiler.getStyleObjectId)(entryName);
+                // Get style data from UxLoaderUtils compilation (handles LESS/CSS)
+                const {
+                  files: compFiles
+                } = await _UxLoaderUtils.default.compileUxToJavascript({
+                  path: id,
+                  content
+                }, {
+                  projectPath: originalProjectPath,
+                  sourceRoot
+                }, isApp, param, compilation);
+                const compiledCode = compFiles[0]?.content || '';
+                // Extract $app_style$ array from compiled code
+                let styleSheet = {};
+                const styleMatch = compiledCode.match(/var \$app_style\$ = (\[[\s\S]*?\]);?\s*(?:import|export|var |const |$)/);
+                if (styleMatch) {
+                  if (styleMatch) {
+                    styleSheet = (0, _TemplateCompiler.parseStyleArray)(styleMatch[1]);
+                  }
+                }
+                // Write css.json
+                const cssPath = _path.default.join(buildPath, `${isApp ? 'app' : pageName}.css.json`);
+                _fsExtra.default.ensureDirSync(_path.default.dirname(cssPath));
+                _fsExtra.default.writeJSONSync(cssPath, Object.keys(styleSheet).length ? {
+                  [String(sid)]: styleSheet
+                } : {}, param.mode === 'production' ? undefined : {
+                  spaces: 2
+                });
+                // Write template.json (with style inlining)
+                if (templateNode && !isApp) {
+                  const tplPath = _path.default.join(buildPath, `${pageName}.template.json`);
+                  _fsExtra.default.ensureDirSync(_path.default.dirname(tplPath));
+                  _fsExtra.default.writeJSONSync(tplPath, (0, _TemplateCompiler.uxToTemplateJson)(templateNode, sid, styleSheet, importMap, _path.default.dirname(pageName)), param.mode === 'production' ? undefined : {
+                    spaces: 2
+                  });
+                  // Worklist BFS over nested <import> chain so transitively imported
+                  // components (entry → compA → compB → compC) also get template.json
+                  const worklist = [];
+                  const visited = new Set();
+                  for (const [compName, compPath] of Object.entries(importMap)) {
+                    const compUxPath = _path.default.resolve(_path.default.dirname(id), `../../${compPath}.ux`);
+                    worklist.push({
+                      compName,
+                      compPath,
+                      compUxPath
+                    });
+                  }
+                  while (worklist.length) {
+                    const {
+                      compName,
+                      compPath,
+                      compUxPath
+                    } = worklist.shift();
+                    if (visited.has(compPath)) continue;
+                    visited.add(compPath);
+                    if (!_fsExtra.default.existsSync(compUxPath)) continue;
+                    const compContent = _fsExtra.default.readFileSync(compUxPath, 'utf-8');
+                    const compDoc = parse5.parseFragment(compContent, {
+                      scriptingEnabled: false
+                    });
+                    let compTpl = null;
+                    const compImportMap = {};
+                    for (const node of compDoc.childNodes) {
+                      if (node.nodeName === 'template') compTpl = node;else if (node.nodeName === 'import') {
+                        const n = node.attrs?.find(a => a.name === 'name');
+                        const s = node.attrs?.find(a => a.name === 'src');
+                        if (n && s) {
+                          const nestedAbsPath = _path.default.resolve(_path.default.dirname(compUxPath), s.value).replace(/\.ux$/, '');
+                          const nestedPath = _path.default.relative(srcPath, nestedAbsPath).replace(/\\/g, '/');
+                          compImportMap[n.value.toLowerCase()] = nestedPath;
+                          if (!visited.has(nestedPath)) {
+                            worklist.push({
+                              compName: n.value.toLowerCase(),
+                              compPath: nestedPath,
+                              compUxPath: _path.default.resolve(_path.default.dirname(compUxPath), s.value)
+                            });
+                          }
+                        }
+                      }
+                    }
+                    if (!compTpl) continue;
+                    const compTplPath = _path.default.join(buildPath, `${compPath}.template.json`);
+                    _fsExtra.default.ensureDirSync(_path.default.dirname(compTplPath));
+                    const compResult = await _UxLoaderUtils.default.compileUxToJavascript({
+                      path: compUxPath,
+                      content: compContent
+                    }, {
+                      projectPath: originalProjectPath,
+                      sourceRoot
+                    }, false, param, compilation);
+                    let compStyleSheet = {};
+                    const compCode = compResult.files[0]?.content || '';
+                    const csm = compCode.match(/var \$app_style\$ = (\[[\s\S]*?\]);?\s*(?:import|export|var |const |$)/);
+                    if (csm) {
+                      compStyleSheet = (0, _TemplateCompiler.parseStyleArray)(csm[1]);
+                    }
+                    const compSid = (0, _TemplateCompiler.getStyleObjectId)(compPath);
+                    _fsExtra.default.writeJSONSync(compTplPath, (0, _TemplateCompiler.uxToTemplateJson)(compTpl, compSid, compStyleSheet, compImportMap, _path.default.dirname(compPath)), param.mode === 'production' ? undefined : {
+                      spaces: 2
+                    });
+                    const compCssPath = _path.default.join(buildPath, `${compPath}.css.json`);
+                    _fsExtra.default.writeJSONSync(compCssPath, Object.keys(compStyleSheet).length ? {
+                      [String(compSid)]: compStyleSheet
+                    } : {}, param.mode === 'production' ? undefined : {
+                      spaces: 2
+                    });
+                    const compJsPath = _path.default.join(buildPath, `${compPath}.js`);
+                    const exportMatch = compCode.match(/export\s+default\s+([\s\S]*?);?\s*$/);
+                    const compObj = exportMatch ? exportMatch[1].trim() : '{}';
+                    const compVarName = compName.replace(/-/g, '_') + '_default';
+                    const compJsContent = `let $style$${compSid} = {"@info":{"styleObjectId":${compSid}}};\nconst $app_style$${compSid} = $style$${compSid};\nvar ${compVarName} = ${compObj};\n$app_define$("@app-component/${compName}", [], function($app_require$, $app_exports$, $app_module$) {\n  $app_module$.exports = ${compVarName}.default || ${compVarName};\n  $app_module$.exports.style = $app_style$${compSid};\n});\n`;
+                    _fsExtra.default.writeFileSync(compJsPath, compJsContent);
+                  }
+                }
+              }
+              const {
+                files
+              } = await _UxLoaderUtils.default.compileUxToJavascript({
+                path: id,
+                content
+              }, {
+                projectPath: originalProjectPath,
+                sourceRoot
+              }, isApp, param, compilation);
+              return files[0]?.content || '';
+            }
+          }]
+        });
+        // Extract the output code
+        if (result && !Array.isArray(result)) {
+          const output = result.output;
+          if (output?.[0]?.code) {
+            const code = wrapOutput(output[0].code, entryName, entryName === 'app');
+            _fsExtra.default.writeFileSync(outputFile, code);
+          }
+        } else if (Array.isArray(result) && result[0]) {
+          const output = result[0].output;
+          if (output?.[0]?.code) {
+            const code = wrapOutput(output[0].code, entryName, entryName === 'app');
+            _fsExtra.default.writeFileSync(outputFile, code);
+          }
+        }
+      } catch (err) {
+        console.warn(`vite: failed to build ${entryName}:`, err.message);
+      }
+    }
+    // Second pass: compile ALL .ux files that weren't entry pages
+    // Each .ux file gets its own template.json + css.json + js
+    const allUxFiles = [];
+    const findUx = dir => {
+      for (const f of _fsExtra.default.readdirSync(dir, {
+        withFileTypes: true
+      })) {
+        const p = _path.default.join(dir, f.name);
+        if (f.isDirectory() && f.name !== 'node_modules') findUx(p);else if (f.name.endsWith('.ux')) allUxFiles.push(p);
+      }
+    };
+    findUx(srcPath);
+    const compiledEntries = new Set(Object.values(entries).map(v => _path.default.resolve(originalProjectPath, v.split('?')[0])));
+    for (const uxFile of allUxFiles) {
+      if (compiledEntries.has(uxFile)) continue; // already compiled as entry
+      if (uxFile.endsWith('/app.ux')) continue; // app.ux handled separately
+      const relPath = _path.default.relative(srcPath, uxFile).replace(/\.ux$/, '');
+      const outputJs = _path.default.join(buildPath, `${relPath}.js`);
+      const outputTpl = _path.default.join(buildPath, `${relPath}.template.json`);
+      const outputCss = _path.default.join(buildPath, `${relPath}.css.json`);
+      if (_fsExtra.default.existsSync(outputTpl)) continue; // already generated by parent page
+      const content = _fsExtra.default.readFileSync(uxFile, 'utf-8');
+      const parse5 = require("aiot-parse5");
+      const doc = parse5.parseFragment(content, {
+        scriptingEnabled: false
+      });
+      let templateNode = null;
+      const importMap = {};
+      for (const node of doc.childNodes) {
+        if (node.nodeName === 'template') templateNode = node;else if (node.nodeName === 'import') {
+          const nameAttr = node.attrs?.find(a => a.name === 'name');
+          const srcAttr = node.attrs?.find(a => a.name === 'src');
+          if (nameAttr && srcAttr) {
+            const compPath = _path.default.resolve(_path.default.dirname(uxFile), srcAttr.value).replace(/\.ux$/, '');
+            importMap[nameAttr.value.toLowerCase()] = _path.default.relative(srcPath, compPath).replace(/\\/g, '/');
+          }
+        }
+      }
+      // Compute styleObjectId
+      const sid = (0, _TemplateCompiler.getStyleObjectId)(relPath);
+      // Compile with UxLoaderUtils to get style data and script
+      const compilation = {
+        entries: [uxFile]
+      };
+      try {
+        const {
+          files
+        } = await _UxLoaderUtils.default.compileUxToJavascript({
+          path: uxFile,
+          content
+        }, {
+          projectPath: originalProjectPath,
+          sourceRoot
+        }, false, param, compilation);
+        const compCode = files[0]?.content || '';
+        // Extract style
+        let styleSheet = {};
+        const csm = compCode.match(/var \$app_style\$ = (\[[\s\S]*?\]);?\s*(?:import|export|var |const |$)/);
+        if (csm) {
+          styleSheet = (0, _TemplateCompiler.parseStyleArray)(csm[1]);
+        }
+        // Generate template.json
+        if (templateNode) {
+          _fsExtra.default.ensureDirSync(_path.default.dirname(outputTpl));
+          _fsExtra.default.writeJSONSync(outputTpl, (0, _TemplateCompiler.uxToTemplateJson)(templateNode, sid, styleSheet, Object.keys(importMap).length ? importMap : undefined, _path.default.dirname(relPath)), param.mode === 'production' ? undefined : {
+            spaces: 2
+          });
+        }
+        // Generate css.json
+        _fsExtra.default.ensureDirSync(_path.default.dirname(outputCss));
+        _fsExtra.default.writeJSONSync(outputCss, Object.keys(styleSheet).length ? {
+          [String(sid)]: styleSheet
+        } : {}, param.mode === 'production' ? undefined : {
+          spaces: 2
+        });
+        // Generate js
+        const exportMatch = compCode.match(/export\s+default\s+([\s\S]*?);?\s*$/);
+        const compObj = exportMatch ? exportMatch[1].trim() : '{}';
+        const compName = _path.default.basename(relPath).toLowerCase();
+        const varName = compName.replace(/-/g, '_') + '_default';
+        _fsExtra.default.ensureDirSync(_path.default.dirname(outputJs));
+        _fsExtra.default.writeFileSync(outputJs, `let $style$${sid} = {"@info":{"styleObjectId":${sid}}};\nconst $app_style$${sid} = $style$${sid};\nvar ${varName} = ${compObj};\n$app_define$("@app-component/${compName}", [], function($app_require$, $app_exports$, $app_module$) {\n  $app_module$.exports = ${varName}.default || ${varName};\n  $app_module$.exports.style = $app_style$${sid};\n});\n`);
+      } catch {}
+    }
+  }
+  async clean(param) {
+    const {
+      outputPath,
+      releasePath,
+      projectPath
+    } = param;
+    _UxCompileUtil.default.clean([outputPath, releasePath].map(item => _path.default.resolve(projectPath, item)));
+  }
+}
+function wrapOutput(code, entryName, isApp) {
+  const componentName = _path.default.parse(entryName).name;
+  const defineId = isApp ? '@app-component/app' : `@app-component/${componentName}`;
+  const bootstrapId = isApp ? '@app-application/app' : `@app-component/${componentName}`;
+  // Remove IIFE wrapper: var _page_ = (function(...) { ... return xxx; })(...);
+  // Only remove the FIRST line and the LAST return+closing
+  if (code.startsWith('var _page_')) {
+    // Remove first line (the IIFE opening)
+    const firstNewline = code.indexOf('\n');
+    code = code.slice(firstNewline + 1);
+    // Remove the last return statement and closing })();
+    const lastReturn = code.lastIndexOf('\treturn ');
+    if (lastReturn !== -1) {
+      const afterReturn = code.indexOf('\n', lastReturn);
+      code = code.slice(0, lastReturn) + code.slice(afterReturn + 1);
+    }
+    // Remove the closing })(); or })(...)
+    const lastClose = code.lastIndexOf('})();');
+    if (lastClose !== -1) {
+      code = code.slice(0, lastClose);
+    } else {
+      const lastClose2 = code.lastIndexOf('})(');
+      if (lastClose2 !== -1) {
+        code = code.slice(0, lastClose2);
+      }
+    }
+  }
+  // Remove rolldown region comments
+  code = code.replace(/\/\/#region[^\n]*\n/g, '');
+  code = code.replace(/\/\/#endregion[^\n]*/g, '');
+  // Remove rolldown runtime helpers (not needed in final output)
+  code = code.replace(/var __defProp = Object\.defineProperty;\n?/g, '');
+  code = code.replace(/var __exportAll = [\s\S]*?return target;\s*\};\n?/g, '');
+  // Inline __exportAll calls: __exportAll({key: () => value, ...}) -> {key: value, ...}
+  // Match __exportAll(...) or /* @__PURE__ */ __exportAll(...)
+  code = code.replace(/(?:\/\* @__PURE__ \*\/\s*)?__exportAll\(\s*\{([\s\S]*?)\}\s*\)/g, (_match, body) => {
+    // Replace each "key: () => value" with "get key() { return value }" for proper live binding
+    const inlined = body.replace(/(\w+)\s*:\s*\(\)\s*=>\s*([^,\n}]+?)([,\n])/g, 'get $1() { return $2; }$3');
+    return `{${inlined}}`;
+  });
+  // Remove Object.defineProperty for Symbol.toStringTag
+  code = code.replace(/\s*Object\.defineProperty\(\w+,\s*Symbol\.toStringTag[^;]*;\s*/g, '');
+  // Extract the default export variable
+  let exportVar = '_default';
+  const m1 = code.match(/export\s*\{\s*(\w+)\s+as\s+default\s*\}/);
+  if (m1) {
+    exportVar = m1[1];
+    code = code.replace(m1[0], '');
+  }
+  code = code.replace(/export\s+default\s+(\w+)\s*;?/g, (_, v) => {
+    exportVar = v;
+    return '';
+  });
+  code = code.replace(/export\s+\{[^}]*\}\s*;?/g, '');
+  // Find the return statement variable (IIFE returns the component)
+  const returnMatch = code.match(/return\s+(\w+)\s*;?\s*$/);
+  if (returnMatch) {
+    exportVar = returnMatch[1];
+    code = code.replace(returnMatch[0], '');
+  }
+  // Generate styleObjectId hash
+  const styleId = (0, _TemplateCompiler.getStyleObjectId)(entryName);
+  return `let $style$${styleId} = {"@info":{"styleObjectId":${styleId}}};
+const $app_style$${styleId} = $style$${styleId};
+${code.trim()}
+$app_define$("${defineId}", [], function($app_require$, $app_exports$, $app_module$) {
+  $app_module$.exports = ${exportVar}.default || ${exportVar};
+  $app_module$.exports.style = $app_style$${styleId};
+});
+$app_bootstrap$("${bootstrapId}");
+`;
+}
+var _default = exports.default = ViteCompiler;

package/lib/compiler/javascript/interface/IJavascriptCompileOption.d.ts

@@ -40,6 +40,10 @@ interface IJavascriptCompileOption extends ICompileParam {
      * 禁用 jsc
      */
     enableJsc?: boolean;
+    /**
+     * 启用 VRU 包装格式（release 模式生成 manifest+CERT+inner-vru 的双层 RPK）
+     */
+    enableVru?: boolean;
     /**
      * 启用 protobuf
      */
@@ -48,6 +52,11 @@ interface IJavascriptCompileOption extends ICompileParam {
      * 启用应用自动化测试
      */
     enableE2e?: boolean;
+    /**
+     * 自动化测试配置文件路径
+     *
+     */
+    e2eConfigPath?: string;
     /**
      * 启用 png8 压缩
      */

package/lib/compiler/javascript/vela/VelaWebpackConfigurator.d.ts

@@ -8,7 +8,9 @@ declare class VelaWebpackConfigurator implements IWebpackConfigurator {
     protected createWrapPlugin(): RspackPluginInstance;
     protected createBundleAnalyzerPlugin(): any;
     /**
-     * 通过读取 manifest.json 生成 entry
+     * 生成entry
+     * 1. 通过读取 manifest.json 生成 entry
+     * 2. 通过自动化测试的entry配置生成entry
      * @returns
      */
     createEntry(): string | EntryObject | string[];

package/lib/compiler/javascript/vela/VelaWebpackConfigurator.js

@@ -9,6 +9,7 @@ var _path = _interopRequireDefault(require("path"));
 var _UxFileUtils = _interopRequireDefault(require("../../../utils/ux/UxFileUtils"));
 var _WrapPlugin = _interopRequireDefault(require("./plugin/WrapPlugin"));
 var _UxCompileUtil = _interopRequireDefault(require("./utils/UxCompileUtil"));
+var _UxUtil = _interopRequireDefault(require("@aiot-toolkit/parser/lib/ux/utils/UxUtil"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class VelaWebpackConfigurator {
   createPlugins() {
@@ -34,7 +35,9 @@ class VelaWebpackConfigurator {
   }
 
   /**
-   * 通过读取 manifest.json 生成 entry
+   * 生成entry
+   * 1. 通过读取 manifest.json 生成 entry
+   * 2. 通过自动化测试的entry配置生成entry
    * @returns
    */
   createEntry() {
@@ -44,7 +47,19 @@ class VelaWebpackConfigurator {
     } = this.param;
     const configFilePath = _UxFileUtils.default.getManifestFilePath(this.param.projectPath, this.param.sourceRoot);
     if (_fsExtra.default.existsSync(configFilePath)) {
+      // 1
       const config = _fsExtra.default.readJSONSync(configFilePath);
+      // 2
+      if (this.param.e2eConfigPath && this.param.enableE2e) {
+        const e2eConfig = _UxUtil.default.getE2eConfig({
+          projectPath: this.param.projectPath,
+          e2eConfigPath: this.param.e2eConfigPath
+        });
+        const testPagePath = _path.default.parse(_path.default.relative(_path.default.join(this.param.projectPath, sourceRoot), _path.default.join(e2eConfig.dir, e2eConfig.entry.path)).replaceAll(_path.default.sep, _path.default.posix.sep));
+        config.router.pages[testPagePath.dir] = {
+          component: testPagePath.name
+        };
+      }
       return _UxCompileUtil.default.resolveEntries(config, _path.default.resolve(projectPath, sourceRoot), projectPath);
     } else {
       throw new Error(`Configuration file does not exist: ${configFilePath}`);

package/lib/compiler/javascript/vela/interface/IManifest.d.ts

@@ -8,6 +8,10 @@ interface IWidget {
     sizes: string[];
     type?: string;
 }
+interface IWidgetProvider {
+    name: string;
+    path: string;
+}
 /**
  * vela manifest文件对应的数据结构
  */
@@ -29,12 +33,20 @@ export default interface IManifest {
         entry: string;
         pages: Dictionary<{
             component?: string;
+            launchMode?: string;
         }>;
+        floatingWindows?: any;
     };
     services: IService[] | Record<string, IService>;
     minAPILevel?: number;
     packageInfo?: Dictionary<string | number>;
+    widgetProvider?: IWidgetProvider[];
     icon: string;
+    workers?: {
+        entries: {
+            file: string;
+        }[];
+    };
 }
 export interface IFeatures {
     name: string;

package/lib/compiler/javascript/vela/plugin/WrapPlugin.d.ts

@@ -4,7 +4,16 @@ declare class WrapPlugin {
     private compilerOption;
     constructor(compilerOption: IJavascriptCompileOption);
     apply(compiler: Compiler): void;
+    private getComponentName;
+    private findMatching;
+    /**
+     * Extract keyed modules from rspack's __webpack_modules__ object
+     */
+    private extractModules;
+    /**
+     * Clean a module body into blueos-pack format component block
+     */
+    private buildBlock;
     private wrap;
-    private translateStyleFunc;
 }
 export default WrapPlugin;