@aiot-toolkit/aiotpack 2.1.0-prender.13 → 2.1.0-prender.14

package/lib/compiler/javascript/TemplateCompiler.js

@@ -236,6 +236,8 @@ function uxToTemplateJson(templateNode, styleObjectId, styleSheet, importMap, pa
   const rootEl = children.find(n => n.tagName && n.nodeName !== '#text');
   if (!rootEl) return {};
   const result = elementToJson(rootEl, styleSheet, importMap, undefined, pageDir);
+  assertNoRelativeAssetPaths(result, pageDir);
+  assertNoDelimitersInEvents(result, pageDir);
   const componentsForRoot = componentsMap && Object.keys(componentsMap).length ? componentsMap : importMap;
   if (componentsForRoot && Object.keys(componentsForRoot).length) {
     result.components = {
@@ -259,6 +261,175 @@ function uxToTemplateJson(templateNode, styleObjectId, styleSheet, importMap, pa
 /** Add this. prefix to variable references in an expression */
 // blueos-pack's pathTestRE: matches simple paths like a.b.c, a['key'], a[0], a[$idx]
 const pathTestRE = /^[A-Za-z_$][\w$]*(?:\.[\w$]+|\['.*?'\]|\[".*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/;
+
+// Attributes whose value is a resource path and therefore must be rewritten from
+// `./x` / `../x` (relative to the owning .ux file) to an rpk-root absolute path.
+// Runtime resolves <image src> against the rpk root, so a relative path emitted
+// from a nested component directory never resolves and falls back to a placeholder.
+const PATH_ATTRS = new Set(['src', 'href', 'alt']);
+const ARROW_RE = /=>/;
+
+/**
+ * Canonical event key for an `@x` / `onx` attribute.
+ *
+ * Every event name the platform defines is a lowercase single word
+ * (`click`, `longpress`, `touchstart`, `animationiteration`, ... — 72 of them
+ * across vela and android, none camelCase or hyphenated), and the parser's own
+ * `translateEventName` just drops the prefix. Camel-casing the remainder turned
+ * `on-long-press` into `LongPress`, which matches no event and silently never
+ * fires, so separators are removed and the name lowercased instead.
+ */
+function normalizeEventName(name) {
+  const stripped = name.startsWith('@') ? name.slice(1) : name.replace(/^on/, '');
+  return stripped.replace(/[-_]/g, '').toLowerCase();
+}
+
+/**
+ * Strip one wrapping `{{ ... }}` from an attribute value.
+ *
+ * Only the outer pair is removed, and only when it actually wraps the whole
+ * value — `{{()=>{ x() }}}` must yield `()=>{ x() }`, so a global
+ * `replace(/\{\{|\}\}/g, '')` is wrong: it would also eat the arrow body's
+ * braces. A value that merely contains an interpolation (`a {{b}} c`) is left
+ * alone; callers that need that do their own splitting.
+ */
+function stripTemplateDelimiters(value) {
+  let v = (value ?? '').trim();
+  if (!v.startsWith('{{') || !v.endsWith('}}')) return v;
+  const inner = v.slice(2, -2);
+  // Reject `{{a}} + {{b}}`, where the opening pair closes before the end.
+  let depth = 0;
+  for (let i = 0; i < inner.length; i++) {
+    if (inner[i] === '{') depth++;else if (inner[i] === '}') {
+      depth--;
+      if (depth < 0) return v;
+    }
+  }
+  return depth === 0 ? inner.trim() : v;
+}
+function isRelAssetPath(v) {
+  return v.startsWith('./') || v.startsWith('../');
+}
+function resolveRelFromPageDir(rel, pageDir) {
+  // A trailing slash is significant when the path is a prefix fragment of a
+  // concatenated expression ('./assets/full/' + lang + '.png') — dropping it
+  // would yield '/.../fullcn.png'.
+  const trailing = rel.endsWith('/') ? '/' : '';
+  const segments = pageDir.split('/').filter(Boolean).concat(rel.split('/'));
+  const stack = [];
+  for (const seg of segments) {
+    if (seg === '..') stack.pop();else if (seg && seg !== '.') stack.push(seg);
+  }
+  return '/' + stack.join('/') + trailing;
+}
+
+/**
+ * Rewrite relative resource-path string literals inside a generated expression.
+ * Dynamic `src="{{'./assets/' + lang + '.png'}}"` compiles to a `$src` function
+ * body, so the path lives in a literal rather than a plain attribute value — the
+ * static-attribute rewrite never sees it. Only literals starting with ./ or ../
+ * are touched, so suffix fragments like '.png' pass through untouched.
+ */
+function rewriteRelPathLiterals(exprSrc, pageDir) {
+  let out = '';
+  let i = 0;
+  while (i < exprSrc.length) {
+    const ch = exprSrc[i];
+    if (ch !== "'" && ch !== '"') {
+      out += ch;
+      i++;
+      continue;
+    }
+    const quote = ch;
+    let j = i + 1;
+    let raw = '';
+    let closed = false;
+    while (j < exprSrc.length) {
+      const c = exprSrc[j];
+      if (c === '\\') {
+        raw += c + (exprSrc[j + 1] ?? '');
+        j += 2;
+        continue;
+      }
+      if (c === quote) {
+        closed = true;
+        break;
+      }
+      raw += c;
+      j++;
+    }
+    if (!closed) {
+      out += exprSrc.slice(i);
+      break;
+    }
+    const unescaped = raw.replace(/\\(['"\\])/g, '$1');
+    if (isRelAssetPath(unescaped)) {
+      const abs = resolveRelFromPageDir(unescaped, pageDir);
+      out += quote + abs.replace(/\\/g, '\\\\').replace(new RegExp(quote, 'g'), '\\' + quote) + quote;
+    } else {
+      out += quote + raw + quote;
+    }
+    i = j + 1;
+  }
+  return out;
+}
+const REL_LITERAL_IN_EXPR_RE = /(['"])\.\.?\//;
+
+/**
+ * Fail the build when a template still carries a relative resource path, in a
+ * static attr or inside a `$`-bound expression's literals. Runtime resolves
+ * these against the rpk root, silently falling back to a placeholder image —
+ * far harder to diagnose on-device than a pack-time error.
+ */
+function assertNoRelativeAssetPaths(root, pageDir) {
+  const offenders = [];
+  const walk = node => {
+    if (!node || typeof node !== 'object') return;
+    const attr = node.attr;
+    if (attr && typeof attr === 'object') {
+      for (const [key, val] of Object.entries(attr)) {
+        if (typeof val !== 'string') continue;
+        const bare = key.startsWith('$') ? key.slice(1) : key;
+        if (!PATH_ATTRS.has(bare)) continue;
+        const bad = key.startsWith('$') ? REL_LITERAL_IN_EXPR_RE.test(val) : isRelAssetPath(val);
+        if (bad) offenders.push(`<${node.type ?? '?'} ${key}="${val}">`);
+      }
+    }
+    if (Array.isArray(node.children)) node.children.forEach(walk);
+  };
+  walk(root);
+  if (offenders.length) {
+    throw new Error(`[template] ${offenders.length} relative resource path(s) survived rewriting` + `${pageDir ? ` in ${pageDir}` : ' (no pageDir supplied)'}. Runtime resolves src/href ` + `against the rpk root, so these render a placeholder instead of the asset:\n` + offenders.map(o => `  ${o}`).join('\n'));
+  }
+}
+
+/**
+ * Fail the build when an event value still carries template delimiters. Runtime
+ * cannot recover: the `$`-prefixed form fails to compile (logged, event skipped)
+ * and the bare form is looked up as a method literally named `{{fn}}` (silent).
+ * Either way the handler is dead, so catching it at pack time is the only way
+ * the breakage is visible before the device.
+ */
+function assertNoDelimitersInEvents(root, pageDir) {
+  const offenders = [];
+  const walk = node => {
+    if (!node || typeof node !== 'object') return;
+    const events = node.events;
+    if (events && typeof events === 'object') {
+      for (const [key, val] of Object.entries(events)) {
+        if (typeof val !== 'string') continue;
+        if (val.includes('{{') || val.includes('}}')) {
+          offenders.push(`<${node.type ?? '?'} ${key}="${val}">`);
+        }
+      }
+    }
+    if (Array.isArray(node.children)) node.children.forEach(walk);
+  };
+  walk(root);
+  if (offenders.length) {
+    throw new Error(`[template] ${offenders.length} event handler(s) still contain template delimiters` + `${pageDir ? ` in ${pageDir}` : ''}. Runtime cannot compile or resolve these, so the ` + `events are silently dead:\n` + offenders.map(o => `  ${o}`).join('\n'));
+  }
+}
 function tryEvalStaticShowLiteral(expr) {
   if (/^'[^']*'$/.test(expr) || /^"[^"]*"$/.test(expr)) {
     const inner = expr.slice(1, -1);
@@ -588,11 +759,18 @@ function elementToJson(el, styleSheet, importMap, scopeVars, pageDir) {
     if (name === 'class') {
       className = value.replace(/\s+/g, ' ').trim();
     } else if (name.startsWith('@') || name.startsWith('on') && name.length > 2) {
-      const rawEvtName = name.startsWith('@') ? name.slice(1) : name.replace(/^on/, '');
-      const evtName = rawEvtName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-      // Events with parameters use $event format with function wrapper
-      const evtVal = value.trim();
-      if (evtVal.includes('(')) {
+      const evtName = normalizeEventName(name);
+      // Event values may be written bare (@click="fn") or wrapped in template
+      // delimiters (@click="{{fn}}"); both mean the same thing, so strip the
+      // delimiters before classifying. Leaving them in emits `{{fn}}`, which
+      // runtime either fails to compile ($-form) or looks up as a method name
+      // literally called "{{fn}}" (bare form) — a silent dead event either way.
+      const evtVal = stripTemplateDelimiters(value);
+      // An arrow function is already a handler; wrapping it in `function (evt)`
+      // and appending evt to its call would both mis-bind and drop the event arg.
+      if (ARROW_RE.test(evtVal)) {
+        events[`$${evtName}`] = `function (evt) { return (${addThisPrefix(evtVal)})(evt); }`;
+      } else if (evtVal.includes('(')) {
         // Add evt as last parameter
         const withEvt = evtVal.replace(/\)$/, evtVal.includes('()') ? 'evt)' : ', evt)');
         events[`$${evtName}`] = `function (evt) { return ${addThisPrefix(withEvt)}; }`;
@@ -750,11 +928,16 @@ function elementToJson(el, styleSheet, importMap, scopeVars, pageDir) {
     } else if (/\{\{.*\}\}/.test(value)) {
       // Dynamic binding - build expression from mixed static/dynamic parts
       const parts = value.split(/(\{\{[\s\S]*?\}\})/);
-      const exprs = parts.filter(Boolean).map(p => {
+      let exprs = parts.filter(Boolean).map(p => {
         const m = p.match(/^\{\{([\s\S]*?)\}\}$/);
         if (m) return addThisPrefix(m[1].trim());
         return `'${p.replace(/'/g, "\\'")}'`;
       });
+      // Resource-path attrs carry their path inside the expression's string
+      // literals; rewrite those too so dynamic src matches static src form.
+      if (PATH_ATTRS.has(name) && pageDir) {
+        exprs = exprs.map(e => rewriteRelPathLiterals(e, pageDir));
+      }
       const camelName = '$' + name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
       const plainName = name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
       // Handle literal values (null, true, false, numbers)
@@ -793,15 +976,8 @@ function elementToJson(el, styleSheet, importMap, scopeVars, pageDir) {
       // Normalize relative path attrs (src, href, alt) to absolute paths from src root.
       // alt can also carry prose (e.g. "blank") — only rewrite when the value starts with
       // ./ or ../ so image alt-text prose passes through untouched.
-      const isRelPath = staticVal.startsWith('./') || staticVal.startsWith('../');
-      if (staticVal && isRelPath && (name === 'src' || name === 'href' || name === 'alt') && pageDir) {
-        // Resolve relative to pageDir, then make absolute from src root
-        const segments = pageDir.split('/').filter(Boolean).concat(staticVal.split('/'));
-        const stack = [];
-        for (const seg of segments) {
-          if (seg === '..') stack.pop();else if (seg && seg !== '.') stack.push(seg);
-        }
-        staticVal = '/' + stack.join('/');
+      if (staticVal && isRelAssetPath(staticVal) && PATH_ATTRS.has(name) && pageDir) {
+        staticVal = resolveRelFromPageDir(staticVal, pageDir);
       }
       attrObj[name.replace(/-([a-z])/g, (_, c) => c.toUpperCase())] = staticVal;
       if (name === 'id') hasBind = true;

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

@@ -11,9 +11,22 @@ declare class ViteCompiler implements ICompiler {
     clean(param: ICompileParam & IJavascriptCompileOption): Promise<void>;
 }
 declare function stripDeadDefProp(code: string): string;
+/**
+ * Build a sub-component's standalone `.js`.
+ *
+ * A component is registered as its own `$app_define$` module and loaded
+ * independently at runtime — the host page bundle does not carry its code. So
+ * everything the component's `<script>` declares at module level has to survive:
+ * feature imports (`import vibrator from "@system.vibrator"`), consts, helpers.
+ * Keeping only the `export default` object literal strips the feature binding and
+ * leaves `vibrator` as a free identifier, which is why the 咪咕/百度地图 keyboard
+ * could no longer vibrate.
+ */
+declare function buildComponentJs(compCode: string, compName: string, compSid: number, relPath: string): string;
 declare function mergeStyleSheets(app: any, page: any): any;
 export declare const __test: {
     stripDeadDefProp: typeof stripDeadDefProp;
     mergeStyleSheets: typeof mergeStyleSheets;
+    buildComponentJs: typeof buildComponentJs;
 };
 export default ViteCompiler;

package/lib/compiler/javascript/ViteCompiler.js

@@ -554,11 +554,7 @@ class ViteCompiler {
                       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);
+                    _fsExtra.default.writeFileSync(compJsPath, buildComponentJs(compCode, compName, compSid, compPath));
                   }
                 }
               }
@@ -685,13 +681,15 @@ class ViteCompiler {
           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 {}
+        _fsExtra.default.writeFileSync(outputJs, buildComponentJs(compCode, compName, sid, relPath));
+      } catch (e) {
+        // A component that fails to emit renders but has no behaviour, so don't
+        // swallow the guard errors that report exactly why.
+        if (e?.message?.startsWith('[component]')) throw e;
+        console.warn(`vite: failed to emit component ${relPath}:`, e?.message ?? e);
+      }
     }
   }
   async clean(param) {
@@ -707,6 +705,51 @@ function stripDeadDefProp(code) {
   const withoutDefine = code.replace(/var __defProp = Object\.defineProperty;\n?/g, '');
   return /\b__defProp\s*\(/.test(withoutDefine) ? code : withoutDefine;
 }
+
+/**
+ * Build a sub-component's standalone `.js`.
+ *
+ * A component is registered as its own `$app_define$` module and loaded
+ * independently at runtime — the host page bundle does not carry its code. So
+ * everything the component's `<script>` declares at module level has to survive:
+ * feature imports (`import vibrator from "@system.vibrator"`), consts, helpers.
+ * Keeping only the `export default` object literal strips the feature binding and
+ * leaves `vibrator` as a free identifier, which is why the 咪咕/百度地图 keyboard
+ * could no longer vibrate.
+ */
+function buildComponentJs(compCode, compName, compSid, relPath) {
+  let code = compCode;
+  // The raw `var $app_style$ = [...]` array is superseded by the $app_style$<sid>
+  // @info reference emitted below; css.json already carries the real style data.
+  const styleLit = extractAppStyleLiteral(code);
+  if (styleLit) {
+    const decl = code.match(/var\s+\$app_style\$\s*=\s*/);
+    if (decl) {
+      const start = decl.index;
+      let end = code.indexOf(styleLit, start) + styleLit.length;
+      if (code[end] === ';') end++;
+      code = code.slice(0, start) + code.slice(end);
+    }
+  }
+  // Turn @system.*/@app-module imports into $app_require$ calls, same as entries.
+  code = rewriteSystemImports(code);
+  let defaultExpr = '{}';
+  const edIdx = code.search(/export\s+default\s+/);
+  if (edIdx !== -1) {
+    const kw = code.slice(edIdx).match(/^export\s+default\s+/);
+    defaultExpr = code.slice(edIdx + kw[0].length).trim().replace(/;\s*$/, '') || '{}';
+    code = code.slice(0, edIdx);
+  }
+  // Named exports have no consumer in a $app_define$ module; keep the declaration.
+  code = code.replace(/\bexport\s+(?=(?:const|let|var|function|class|async)\b)/g, '');
+  const leftoverImport = code.match(/^\s*import\s[^\n]*/m);
+  if (leftoverImport) {
+    throw new Error(`[component] ${relPath} has an unresolved ESM import that cannot be emitted into a ` + `standalone $app_define$ module: ${leftoverImport[0].trim()}\n` + `Only @system.*/@service.*/@android.*/@hap.*/@app-module imports are rewritten to ` + `$app_require$. Inline the dependency into the component or move it behind a feature module.`);
+  }
+  const varName = compName.replace(/-/g, '_') + '_default';
+  const moduleCode = code.trim();
+  return [`let $style$${compSid} = {"@info":{"styleObjectId":${compSid}}};`, `const $app_style$${compSid} = $style$${compSid};`, ...(moduleCode ? [moduleCode] : []), `var ${varName} = ${defaultExpr};`, `$app_define$("@app-component/${compName}", [], function($app_require$, $app_exports$, $app_module$) {`, `  $app_module$.exports = ${varName}.default || ${varName};`, `  $app_module$.exports.style = $app_style$${compSid};`, `});`, ''].join('\n');
+}
 function wrapOutput(code, entryName, isApp) {
   const componentName = _path.default.parse(entryName).name;
   const defineId = isApp ? '@app-component/app' : `@app-component/${componentName}`;
@@ -831,6 +874,7 @@ function mergeStyleSheets(app, page) {
 }
 const __test = exports.__test = {
   stripDeadDefProp,
-  mergeStyleSheets
+  mergeStyleSheets,
+  buildComponentJs
 };
 var _default = exports.default = ViteCompiler;

package/lib/compiler/javascript/vela/utils/Jsc.d.ts

@@ -8,6 +8,7 @@ declare class Jsc {
     private static listFiles;
     private assertJscVersion;
     static wrapAllJsWithIife(buildPath: string): void;
+    private static assertLegacyGlobalBinding;
     private static compareSemver;
 }
 export default Jsc;

package/lib/compiler/javascript/vela/utils/Jsc.js

@@ -10,7 +10,15 @@ var _sharedUtils = require("@aiot-toolkit/shared-utils");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 const REQUIRED_JSC_VERSION = '1.0.9';
-const IIFE_WRAP_PREFIX = 'export default (function (__ctx) {\n' + '  let { requireModule, unRequireModule, $app_define$, $app_bootstrap$, $app_require$,\n' + '        console = global.console } = __ctx;\n' + '  let { setTimeout, clearTimeout, setInterval, clearInterval } = __ctx;\n\n';
+
+// `__ctx` is the page scope whose prototype is `ferryGlobal` (where the runtime
+// registers `runGC` and friends). A bare `global` in legacy page source resolves
+// to QuickJS's real global object, which does NOT carry those APIs — hence
+// `global.runGC()` throws `TypeError: not a function`. Bind `global`/`window`/`self`
+// to `__ctx` so `global.xxx` walks `__ctx → ferryGlobal`. `globalThis` is left
+// untouched (still the real global), so `console` must default from `globalThis`,
+// not `global` — after the rebind `global.console` would look up ferryGlobal.
+const IIFE_WRAP_PREFIX = 'export default (function (__ctx) {\n' + '  const global = __ctx, window = __ctx, self = __ctx;\n' + '  let { requireModule, unRequireModule, $app_define$, $app_bootstrap$, $app_require$,\n' + '        console = globalThis.console } = __ctx;\n' + '  let { setTimeout, clearTimeout, setInterval, clearInterval } = __ctx;\n\n';
 const IIFE_WRAP_SUFFIX = '\n});\n';
 class Jsc {
   constructor(projectPath, buildPath) {
@@ -150,7 +158,25 @@ class Jsc {
       const abs = path.join(buildPath, rel);
       const body = fs.readFileSync(abs, 'utf-8');
       if (body.startsWith('export default (function (__ctx)')) continue;
-      fs.writeFileSync(abs, IIFE_WRAP_PREFIX + body + IIFE_WRAP_SUFFIX, 'utf-8');
+      const wrapped = IIFE_WRAP_PREFIX + body + IIFE_WRAP_SUFFIX;
+      Jsc.assertLegacyGlobalBinding(rel, wrapped);
+      fs.writeFileSync(abs, wrapped, 'utf-8');
+    }
+  }
+
+  // Fail the build if a Component-JS page keeps a bare `global`/`window`/`self`
+  // member access but the wrapper lost its compat alias — otherwise the page
+  // ships and only blows up at runtime (`global.runGC is not a function` →
+  // unhandled promise rejection stuck on the loading page). The alias is emitted
+  // unconditionally by IIFE_WRAP_PREFIX, so this trips only if that prefix
+  // regresses, surfacing the break at pack time instead of on-device.
+  static assertLegacyGlobalBinding(rel, wrapped) {
+    const usesLegacyGlobal = /\b(global|window|self)\s*\./.test(wrapped);
+    if (!usesLegacyGlobal) return;
+    const hasAlias = /\bconst global = __ctx, window = __ctx, self = __ctx;/.test(wrapped);
+    if (!hasAlias) {
+      _sharedUtils.ColorConsole.throw(`[jsc] ${rel} references bare global/window/self but the IIFE wrapper is ` + `missing the \`const global = __ctx, window = __ctx, self = __ctx\` compat ` + `alias. Such a page would throw at runtime (e.g. global.runGC is not a ` + `function) and hang on the loading page.`);
+      throw new Error(`[jsc] ${rel}: missing legacy global compat alias in wrapper`);
     }
   }
   static compareSemver(a, b) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiot-toolkit/aiotpack",
-  "version": "2.1.0-prender.13",
+  "version": "2.1.0-prender.14",
   "description": "The process tool for packaging aiot projects.",
   "keywords": [
     "aiotpack"
@@ -19,16 +19,16 @@
     "test": "node ./__tests__/aiotpack.test.js"
   },
   "dependencies": {
-    "@aiot-toolkit/generator": "2.1.0-prender.13",
-    "@aiot-toolkit/parser": "2.1.0-prender.13",
-    "@aiot-toolkit/shared-utils": "2.1.0-prender.13",
+    "@aiot-toolkit/generator": "2.1.0-prender.14",
+    "@aiot-toolkit/parser": "2.1.0-prender.14",
+    "@aiot-toolkit/shared-utils": "2.1.0-prender.14",
     "@hap-toolkit/aaptjs": "^2.0.0",
     "@rspack/core": "^1.3.9",
     "acorn": "^8.16.0",
     "aiot-parse5": "^1.0.2",
     "astring": "^1.9.0",
     "babel-loader": "^9.1.3",
-    "file-lane": "2.1.0-prender.13",
+    "file-lane": "2.1.0-prender.14",
     "file-loader": "^6.2.0",
     "fs-extra": "^11.2.0",
     "jsrsasign": "^11.1.0",