@aiot-toolkit/aiotpack 2.1.0-prender.16 → 2.1.0-prender.17

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

@@ -79,6 +79,29 @@ declare function stripDeadDefProp(code: string): string;
  */
 declare function dropUnusedUxImports(code: string): string;
 declare function buildComponentJs(compCode: string, compName: string, compSid: number, relPath: string): string;
+/**
+ * Normalize rolldown output: drop its region markers and runtime helpers, and
+ * turn surviving `require("@system.*")` calls into `$app_require$`.
+ */
+declare function stripRolldownArtifacts(code: string): string;
+/**
+ * Move synthesized namespace objects to the top of the flattened scope.
+ *
+ * The `import * as ns` interop bridge reads `ns_exports` from a top-level statement,
+ * so with an import cycle DFS post-order can leave the bridge ahead of the object:
+ * `var` assignment is not hoisted, so it reads undefined and throws before any
+ * `$app_define$` runs. Only getter-only literals move — they have no side effects and
+ * resolve lazily, so relocating one cannot snapshot an undefined or reorder an effect.
+ */
+declare function hoistNamespaceObjects(code: string): string;
+/** Calls through a surviving thunk table are silently dropped, so refuse to emit one. */
+declare function assertNamespaceObjectsInlined(code: string): void;
+/**
+ * Reject a top-level `var` whose eager initializer reads an identifier assigned by a
+ * later top-level `var` — the read yields undefined, which is how an import cycle
+ * surfaces once module bodies are flattened into one scope.
+ */
+declare function assertNoEagerForwardRead(code: string): void;
 declare function mergeStyleSheets(app: any, page: any): any;
 export declare const __test: {
     stripDeadDefProp: typeof stripDeadDefProp;
@@ -89,5 +112,9 @@ export declare const __test: {
     resolveImportSrc: typeof resolveImportSrc;
     findUnbundledRelativeImports: typeof findUnbundledRelativeImports;
     bundleComponentCode: typeof bundleComponentCode;
+    stripRolldownArtifacts: typeof stripRolldownArtifacts;
+    hoistNamespaceObjects: typeof hoistNamespaceObjects;
+    assertNamespaceObjectsInlined: typeof assertNamespaceObjectsInlined;
+    assertNoEagerForwardRead: typeof assertNoEagerForwardRead;
 };
 export default ViteCompiler;

package/lib/compiler/javascript/ViteCompiler.js

@@ -962,8 +962,11 @@ function stripRolldownArtifacts(code) {
   // 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');
+    // A surviving thunk is not a live binding but a function returning one, so
+    // `ns.fn(arg)` drops the argument and returns `fn`. The lookahead (rather than
+    // consuming the separator) is what converts the last property, which is followed
+    // by the closing brace.
+    const inlined = body.replace(/(\w+)\s*:\s*\(\)\s*=>\s*([^,\n}]+?)\s*(?=[,\n]|$)/g, 'get $1() { return $2; }');
     return `{${inlined}}`;
   });
   // Remove Object.defineProperty for Symbol.toStringTag
@@ -991,8 +994,177 @@ function stripRolldownArtifacts(code) {
   if (!/\b__require\b/.test(code)) {
     code = code.replace(/var __require\s*=\s*\/\*[^*]*\*\/\s*\(\(x\)\s*=>[\s\S]*?}\);\n?/g, '');
   }
+  assertNamespaceObjectsInlined(code);
+  code = hoistNamespaceObjects(code);
+  assertNoEagerForwardRead(code);
   return code;
 }
+
+/** A getter-only object literal: `{ get a() { return a; }, get b() { return b; }}`. */
+function isGetterOnlyLiteral(literal) {
+  const inner = literal.slice(1, -1).trim();
+  if (!inner) return false;
+  return inner.split(/,\s*(?=get\s)/).every(p => /^get\s+\w+\s*\(\)\s*\{\s*return\s+[^;{}]+;?\s*\}\s*,?$/.test(p.trim()));
+}
+
+/**
+ * Move synthesized namespace objects to the top of the flattened scope.
+ *
+ * The `import * as ns` interop bridge reads `ns_exports` from a top-level statement,
+ * so with an import cycle DFS post-order can leave the bridge ahead of the object:
+ * `var` assignment is not hoisted, so it reads undefined and throws before any
+ * `$app_define$` runs. Only getter-only literals move — they have no side effects and
+ * resolve lazily, so relocating one cannot snapshot an undefined or reorder an effect.
+ */
+function hoistNamespaceObjects(code) {
+  const hoisted = [];
+  const out = code.replace(/^[ \t]*var\s+(\w+)\s*=\s*(\{[\s\S]*?\});[ \t]*$\n?/gm, (stmt, name, literal) => {
+    if (!isGetterOnlyLiteral(literal)) return stmt;
+    hoisted.push(`var ${name} = ${literal};`);
+    return '';
+  });
+  return hoisted.length ? `${hoisted.join('\n')}\n${out}` : out;
+}
+
+/** Calls through a surviving thunk table are silently dropped, so refuse to emit one. */
+function assertNamespaceObjectsInlined(code) {
+  if (/\b__exportAll\s*\(/.test(code)) {
+    throw new Error(`[js] a namespace object was emitted through the __exportAll helper instead of being ` + `inlined as getters. Calls through it are silently dropped. Offending code:\n` + code.match(/[^\n]*__exportAll\s*\([^\n]*/)[0]);
+  }
+  const thunk = code.match(/^[ \t]*var\s+\w+_exports\s*=\s*\{[^{}]*?\w+\s*:\s*\(\)\s*=>[^\n]*$/m);
+  if (thunk) {
+    throw new Error(`[js] namespace object still holds a thunk property instead of a getter; calls ` + `through it are silently dropped. Offending code:\n${thunk[0]}`);
+  }
+}
+
+/**
+ * Reject a top-level `var` whose eager initializer reads an identifier assigned by a
+ * later top-level `var` — the read yields undefined, which is how an import cycle
+ * surfaces once module bodies are flattened into one scope.
+ */
+function assertNoEagerForwardRead(code) {
+  const stmts = topLevelVarStatements(code);
+  const assignedAt = new Map();
+  for (const s of stmts) if (!assignedAt.has(s.name)) assignedAt.set(s.name, s.at);
+  for (const {
+    name,
+    init,
+    at
+  } of stmts) {
+    if (isLazyInitializer(init)) continue;
+    for (const ref of maskNonReferences(init).matchAll(/[A-Za-z_$][\w$]*/g)) {
+      const refAt = assignedAt.get(ref[0]);
+      if (ref[0] !== name && refAt !== undefined && refAt > at) {
+        throw new Error(`[js] top-level \`var ${name}\` is evaluated before \`${ref[0]}\` is assigned ` + `(assignment appears later in the flattened scope), so it reads undefined. ` + `This is a module ordering bug, usually an import cycle.\n  var ${name} = ${init};`);
+      }
+    }
+  }
+}
+function isLazyInitializer(init) {
+  // A `{` means a block or object literal, where the name may sit in a method or getter
+  // body that runs later — or be a property key, which is no reference at all. Skipping
+  // those trades coverage inside object literals for freedom from false positives.
+  return init.includes('{') || /\bfunction\b|=>|\bclass\b/.test(init);
+}
+
+/** Blank out what looks like an identifier but cannot be a binding reference. */
+function maskNonReferences(src) {
+  return src.replace(/'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|`(?:\\.|[^`\\])*`/g, '""').replace(/\.\s*[A-Za-z_$][\w$]*/g, '');
+}
+
+/**
+ * Split top-level `var NAME = INIT;` statements.
+ *
+ * Needs a real scan rather than a per-line regex: initializers do span lines in bundler
+ * output (array literals, multi-line template literals), and a line-based split would
+ * read template-literal text as identifiers.
+ */
+function topLevelVarStatements(code) {
+  const out = [];
+  let depth = 0;
+  let i = 0;
+  while (i < code.length) {
+    const c = code[i];
+    if (c === '{' || c === '(' || c === '[') {
+      depth++;
+      i++;
+      continue;
+    }
+    if (c === '}' || c === ')' || c === ']') {
+      depth--;
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      i = skipString(code, i);
+      continue;
+    }
+    if (c === '/' && code[i + 1] === '/') {
+      i = code.indexOf('\n', i);
+      if (i === -1) break;
+      continue;
+    }
+    if (c === '/' && code[i + 1] === '*') {
+      i = code.indexOf('*/', i);
+      if (i === -1) break;
+      i += 2;
+      continue;
+    }
+    if (depth === 0 && code.startsWith('var ', i) && (i === 0 || /[\s;}]/.test(code[i - 1]))) {
+      const m = /^var\s+([\w$]+)\s*=\s*/.exec(code.slice(i));
+      if (m) {
+        const initStart = i + m[0].length;
+        const end = findStatementEnd(code, initStart);
+        out.push({
+          name: m[1],
+          init: code.slice(initStart, end).trim(),
+          at: i
+        });
+        i = end;
+        continue;
+      }
+    }
+    i++;
+  }
+  return out;
+}
+function skipString(code, start) {
+  const quote = code[start];
+  let i = start + 1;
+  while (i < code.length) {
+    if (code[i] === '\\') {
+      i += 2;
+      continue;
+    }
+    if (code[i] === quote) return i + 1;
+    i++;
+  }
+  return i;
+}
+function findStatementEnd(code, start) {
+  let depth = 0;
+  let i = start;
+  while (i < code.length) {
+    const c = code[i];
+    if (c === '{' || c === '(' || c === '[') {
+      depth++;
+      i++;
+      continue;
+    }
+    if (c === '}' || c === ')' || c === ']') {
+      depth--;
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === '`') {
+      i = skipString(code, i);
+      continue;
+    }
+    if (depth === 0 && (c === ';' || c === '\n')) return i;
+    i++;
+  }
+  return i;
+}
 function wrapOutput(code, entryName, isApp) {
   const componentName = _path.default.parse(entryName).name;
   const defineId = isApp ? '@app-component/app' : `@app-component/${componentName}`;
@@ -1084,6 +1256,10 @@ const __test = exports.__test = {
   collectReachableUx,
   resolveImportSrc,
   findUnbundledRelativeImports,
-  bundleComponentCode
+  bundleComponentCode,
+  stripRolldownArtifacts,
+  hoistNamespaceObjects,
+  assertNamespaceObjectsInlined,
+  assertNoEagerForwardRead
 };
 var _default = exports.default = ViteCompiler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiot-toolkit/aiotpack",
-  "version": "2.1.0-prender.16",
+  "version": "2.1.0-prender.17",
   "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.16",
-    "@aiot-toolkit/parser": "2.1.0-prender.16",
-    "@aiot-toolkit/shared-utils": "2.1.0-prender.16",
+    "@aiot-toolkit/generator": "2.1.0-prender.17",
+    "@aiot-toolkit/parser": "2.1.0-prender.17",
+    "@aiot-toolkit/shared-utils": "2.1.0-prender.17",
     "@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.16",
+    "file-lane": "2.1.0-prender.17",
     "file-loader": "^6.2.0",
     "fs-extra": "^11.2.0",
     "jsrsasign": "^11.1.0",