@dimina/compiler 1.0.6 → 1.0.8

package/dist/core/view-compiler.cjs

@@ -1,14 +1,16 @@
 "use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const fs = require("node:fs");
+const path = require("node:path");
 const node_worker_threads = require("node:worker_threads");
 const babel = require("@babel/core");
-const types = require("@babel/types");
 const _traverse = require("@babel/traverse");
+const types = require("@babel/types");
 const compilerSfc = require("@vue/compiler-sfc");
 const cheerio = require("cheerio");
-const htmlparser2 = require("htmlparser2");
 const esbuild = require("esbuild");
-const env = require("../env-Chow6VXH.cjs");
+const htmlparser2 = require("htmlparser2");
+const env = require("../env-Cmen1qwy.cjs");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -30,7 +32,10 @@ const htmlparser2__namespace = /* @__PURE__ */ _interopNamespaceDefault(htmlpars
 const traverse = _traverse.default ? _traverse.default : _traverse;
 const fileType = [".wxml", ".ddml"];
 const compileResCache = /* @__PURE__ */ new Map();
-const processedModules = /* @__PURE__ */ new Set();
+const wxsModuleRegistry = /* @__PURE__ */ new Set();
+const wxsFilePathMap = /* @__PURE__ */ new Map();
+const moduleCompileStatus = /* @__PURE__ */ new Map();
+const moduleCompileResults = /* @__PURE__ */ new Map();
 if (!node_worker_threads.isMainThread) {
   node_worker_threads.parentPort.on("message", async ({ pages, storeInfo }) => {
     try {
@@ -55,7 +60,17 @@ if (!node_worker_threads.isMainThread) {
     }
   });
 }
+function clearCompileState() {
+  moduleCompileStatus.clear();
+  moduleCompileResults.clear();
+  compileResCache.clear();
+  wxsModuleRegistry.clear();
+  wxsFilePathMap.clear();
+}
 async function compileML(pages, root, progress) {
+  const workPath = env.getWorkPath();
+  clearCompileState();
+  initWxsFilePathMap(workPath);
   for (const page of pages) {
     const scriptRes = /* @__PURE__ */ new Map();
     buildCompileView(page, false, scriptRes, []);
@@ -75,54 +90,156 @@ async function compileML(pages, root, progress) {
     if (root) {
       const subDir = `${env.getTargetPath()}/${root}`;
       if (!fs.existsSync(subDir)) {
-        fs.mkdirSync(subDir);
+        fs.mkdirSync(subDir, { recursive: true });
       }
       fs.writeFileSync(`${subDir}/${filename}.js`, mergeRender);
     } else {
       const mainDir = `${env.getTargetPath()}/main`;
       if (!fs.existsSync(mainDir)) {
-        fs.mkdirSync(mainDir);
+        fs.mkdirSync(mainDir, { recursive: true });
       }
       fs.writeFileSync(`${mainDir}/${filename}.js`, mergeRender);
     }
     progress.completedTasks++;
   }
 }
+function initWxsFilePathMap(workPath) {
+  wxsFilePathMap.clear();
+  const npmDir = path.join(workPath, "miniprogram_npm");
+  if (fs.existsSync(npmDir)) {
+    scanWxsFiles(npmDir, workPath);
+  }
+}
+function scanWxsFiles(dir, workPath) {
+  try {
+    const items = fs.readdirSync(dir);
+    for (const item of items) {
+      const fullPath = path.join(dir, item);
+      const stat = fs.statSync(fullPath);
+      if (stat.isDirectory()) {
+        scanWxsFiles(fullPath, workPath);
+      } else if (stat.isFile() && item.endsWith(".wxs")) {
+        const relativePath = fullPath.replace(workPath, "").replace(/\.wxs$/, "");
+        const moduleName = relativePath.replace(/[\/\\@\-]/g, "_").replace(/^_/, "");
+        wxsFilePathMap.set(moduleName, fullPath);
+      }
+    }
+  } catch (error) {
+  }
+}
+function registerWxsModule(modulePath) {
+  wxsModuleRegistry.add(modulePath);
+}
+function isRegisteredWxsModule(modulePath) {
+  return wxsModuleRegistry.has(modulePath);
+}
 function buildCompileView(module2, isComponent = false, scriptRes, depthChain = []) {
   const currentPath = module2.path;
+  if (moduleCompileStatus.has(currentPath)) {
+    const status = moduleCompileStatus.get(currentPath);
+    if (status === "pending") {
+      console.warn("[view]", `检测到循环依赖: ${[...depthChain, currentPath].join(" -> ")}`);
+      return { scriptModule: [] };
+    } else if (status === "completed") {
+      return moduleCompileResults.get(currentPath) || { scriptModule: [] };
+    } else if (status === "failed") {
+      console.warn("[view]", `模块编译失败，跳过: ${currentPath}`);
+      return { scriptModule: [] };
+    }
+  }
   if (depthChain.includes(currentPath)) {
-    console.warn(`检测到循环依赖: ${[...depthChain, currentPath].join(" -> ")}`);
+    console.warn("[view]", `检测到循环依赖: ${[...depthChain, currentPath].join(" -> ")}`);
+    return { scriptModule: [] };
   }
-  if (depthChain.length > 100) {
-    console.warn(`检测到深度依赖: ${[...depthChain, currentPath].join(" -> ")}`);
+  if (depthChain.length > 5) {
+    console.warn("[view]", `检测到深度依赖，中断编译: ${[...depthChain, currentPath].join(" -> ")}`);
+    return { scriptModule: [] };
   }
+  moduleCompileStatus.set(currentPath, "pending");
   depthChain = [...depthChain, currentPath];
-  compileModule(module2, isComponent, scriptRes);
-  if (module2.usingComponents) {
-    for (const componentInfo of Object.values(module2.usingComponents)) {
-      const componentModule = env.getComponent(componentInfo);
-      if (!componentModule) {
-        continue;
+  try {
+    const allScriptModules = [];
+    const currentInstruction = compileModule(module2, isComponent, scriptRes);
+    if (currentInstruction && currentInstruction.scriptModule) {
+      allScriptModules.push(...currentInstruction.scriptModule);
+    }
+    if (module2.usingComponents) {
+      for (const componentInfo of Object.values(module2.usingComponents)) {
+        const componentModule = env.getComponent(componentInfo);
+        if (!componentModule) {
+          continue;
+        }
+        if (componentModule.path === module2.path) {
+          console.warn("[view]", `检测到自依赖，跳过处理: ${module2.path}`);
+          continue;
+        }
+        const componentInstruction = buildCompileView(componentModule, true, scriptRes, depthChain);
+        if (componentInstruction && componentInstruction.scriptModule) {
+          for (const sm of componentInstruction.scriptModule) {
+            if (!allScriptModules.find((existing) => existing.path === sm.path)) {
+              allScriptModules.push(sm);
+            }
+          }
+        }
+      }
+    }
+    if (!isComponent && allScriptModules.length > 0) {
+      for (const sm of allScriptModules) {
+        if (!scriptRes.has(sm.path)) {
+          scriptRes.set(sm.path, sm.code);
+        }
       }
-      buildCompileView(componentModule, true, scriptRes, depthChain);
+      compileModuleWithAllWxs(module2, scriptRes, allScriptModules);
     }
+    const result = { scriptModule: allScriptModules };
+    moduleCompileStatus.set(currentPath, "completed");
+    moduleCompileResults.set(currentPath, result);
+    return result;
+  } catch (error) {
+    moduleCompileStatus.set(currentPath, "failed");
+    console.error("[view]", `模块编译失败: ${currentPath}`, error.message);
+    return { scriptModule: [] };
   }
-  processedModules.add(currentPath);
 }
 function compileModule(module2, isComponent, scriptRes) {
   const { tpl, instruction } = toCompileTemplate(isComponent, module2.path, module2.usingComponents, module2.componentPlaceholder);
   if (!tpl) {
-    return;
+    return null;
   }
+  let useCache = false;
+  let cachedCode = null;
   if (!scriptRes.has(module2.path) && compileResCache.has(module2.path)) {
-    const res = compileResCache.get(module2.path);
-    scriptRes.set(module2.path, res);
-    for (const sm of instruction.scriptModule) {
-      if (!scriptRes.has(sm.path)) {
-        scriptRes.set(sm.path, sm.code);
+    const cacheData2 = compileResCache.get(module2.path);
+    if (cacheData2 && typeof cacheData2 === "object" && cacheData2.code && cacheData2.instruction) {
+      cachedCode = cacheData2.code;
+      useCache = true;
+      for (const sm of cacheData2.instruction.scriptModule) {
+        if (!scriptRes.has(sm.path)) {
+          scriptRes.set(sm.path, sm.code);
+        }
       }
+    } else if (typeof cacheData2 === "string") {
+      cachedCode = cacheData2;
+      useCache = true;
     }
-    return;
+  }
+  if (useCache && cachedCode) {
+    scriptRes.set(module2.path, cachedCode);
+    const allWxsModules2 = collectAllWxsModules(scriptRes, /* @__PURE__ */ new Set(), instruction.scriptModule || []);
+    if (allWxsModules2.length > 0) {
+      const existingModules = instruction.scriptModule || [];
+      const mergedModules = [...existingModules];
+      for (const wxsModule of allWxsModules2) {
+        if (!mergedModules.find((existing) => existing.path === wxsModule.path)) {
+          mergedModules.push(wxsModule);
+        }
+      }
+      instruction.scriptModule = mergedModules;
+    }
+    return {
+      ...instruction,
+      scriptModule: allWxsModules2
+    };
   }
   const processedTpl = tpl.replace(/\bthis\./g, "_ctx.");
   const tplCode = compilerSfc.compileTemplate({
@@ -143,7 +260,7 @@ function compileModule(module2, isComponent, scriptRes) {
   });
   let tplComponents = "{";
   for (const tm of instruction.templateModule) {
-    tplComponents += `'${tm.path}':${compilerSfc.compileTemplate({
+    let { code: code2 } = compilerSfc.compileTemplate({
       source: tm.tpl,
       filename: tm.path,
       id: `data-v-${module2.id}`,
@@ -156,36 +273,231 @@ function compileModule(module2, isComponent, scriptRes) {
         mode: "function",
         inline: true
       }
-    }).code},`;
+    });
+    const ast = babel.parseSync(code2);
+    insertWxsToRenderAst(ast, instruction.scriptModule, scriptRes);
+    code2 = babel.transformFromAstSync(ast, "", {
+      comments: false
+    }).code;
+    tplComponents += `'${tm.path}':${code2.replace(/;$/, "").replace(/^"use strict";\s*/, "")},`;
   }
   tplComponents += "}";
   const tplAst = babel.parseSync(tplCode.code);
-  for (const sm of instruction.scriptModule) {
-    if (!scriptRes.has(sm.path)) {
-      scriptRes.set(sm.path, sm.code);
+  insertWxsToRenderAst(tplAst, instruction.scriptModule, scriptRes);
+  const { code: transCode } = babel.transformFromAstSync(tplAst, "", {
+    comments: false
+  });
+  const code = `Module({
+		path: '${module2.path}',
+		id: '${module2.id}',
+		render: ${transCode.replace(/;$/, "").replace(/^"use strict";\s*/, "")},
+		usingComponents: ${JSON.stringify(module2.usingComponents)},
+		tplComponents: ${tplComponents},
+		});`;
+  const allWxsModules = collectAllWxsModules(scriptRes, /* @__PURE__ */ new Set(), instruction.scriptModule || []);
+  if (allWxsModules.length > 0) {
+    const existingModules = instruction.scriptModule || [];
+    const mergedModules = [...existingModules];
+    for (const wxsModule of allWxsModules) {
+      if (!mergedModules.find((existing) => existing.path === wxsModule.path)) {
+        mergedModules.push(wxsModule);
+      }
     }
-    const assignmentExpression = types.assignmentExpression(
-      "=",
-      // 创建赋值表达式
-      types.memberExpression(
-        types.identifier("_ctx"),
-        // 对象标识符
-        types.identifier(sm.path),
-        // 属性标识符
-        false
-        // 是否是计算属性
-      ),
-      // 创建require调用表达式
-      types.callExpression(
-        types.identifier("require"),
-        // 函数标识符
-        [types.stringLiteral(sm.path)]
-        // 参数列表，这里传入字符串字面量'foo'
-      )
-    );
-    const expressionStatement = types.expressionStatement(assignmentExpression);
-    tplAst.program.body[0].expression.body.body.splice(0, 0, expressionStatement);
+    instruction.scriptModule = mergedModules;
+  }
+  const cacheData = {
+    code,
+    instruction
+  };
+  compileResCache.set(module2.path, cacheData);
+  scriptRes.set(module2.path, code);
+  return instruction;
+}
+function processWxsContent(wxsContent, wxsFilePath, scriptModule, workPath, filePath) {
+  let wxsAst;
+  try {
+    wxsAst = babel.parseSync(wxsContent);
+  } catch (error) {
+    console.error(`[view] 解析 wxs 文件失败: ${wxsFilePath}`, error.message);
+    return wxsContent;
+  }
+  traverse(wxsAst, {
+    CallExpression(astPath) {
+      const calleeName = astPath.node.callee.name;
+      if (calleeName === "getRegExp") {
+        const args = astPath.node.arguments;
+        if (args.length > 0) {
+          if (args[0].type === "StringLiteral" && (!args[1] || args[1].type === "StringLiteral")) {
+            let pattern = "";
+            let flags = "";
+            const arg = args[0];
+            if (arg.extra && arg.extra.raw) {
+              pattern = arg.extra.raw.slice(1, -1);
+            } else if (arg.value !== void 0) {
+              pattern = arg.value;
+            } else {
+              pattern = "";
+            }
+            if (args.length > 1) {
+              const flagArg = args[1];
+              if (flagArg.extra && flagArg.extra.raw) {
+                flags = flagArg.extra.raw.slice(1, -1);
+              } else if (flagArg.value !== void 0) {
+                flags = flagArg.value;
+              } else {
+                flags = "";
+              }
+            }
+            const regexLiteral = types.regExpLiteral(pattern, flags);
+            astPath.replaceWith(regexLiteral);
+          } else {
+            const newRegExpArgs = [args[0]];
+            if (args.length > 1) {
+              newRegExpArgs.push(args[1]);
+            }
+            const newRegExpCall = types.newExpression(
+              types.identifier("RegExp"),
+              newRegExpArgs
+            );
+            astPath.replaceWith(newRegExpCall);
+          }
+        }
+      } else if (calleeName === "getDate") {
+        const args = [];
+        for (let i = 0; i < astPath.node.arguments.length; i++) {
+          args.push(astPath.node.arguments[i]);
+        }
+        const newExpr = types.newExpression(types.identifier("Date"), args);
+        astPath.replaceWith(newExpr);
+      } else if (calleeName === "require" && astPath.node.arguments.length > 0 && wxsFilePath) {
+        const requirePath = astPath.node.arguments[0].value;
+        if (requirePath && typeof requirePath === "string") {
+          let resolvedWxsPath;
+          if (filePath && filePath.includes("/miniprogram_npm/")) {
+            const currentWxsDir = path.dirname(wxsFilePath);
+            resolvedWxsPath = path.resolve(currentWxsDir, requirePath);
+            const relativePath = resolvedWxsPath.replace(workPath, "").replace(/\.wxs$/, "");
+            const moduleName = relativePath.replace(/[\/\\@\-]/g, "_").replace(/^_/, "");
+            processWxsDependency(resolvedWxsPath, moduleName, scriptModule, workPath, filePath);
+            astPath.node.arguments[0] = types.stringLiteral(moduleName);
+          } else {
+            const currentWxsDir = path.dirname(wxsFilePath);
+            resolvedWxsPath = path.resolve(currentWxsDir, requirePath);
+            const relativePath = resolvedWxsPath.replace(workPath, "").replace(/\.wxs$/, "");
+            const depModuleName = relativePath.replace(/[\/\\@\-]/g, "_").replace(/^_/, "");
+            processWxsDependency(resolvedWxsPath, depModuleName, scriptModule, workPath, filePath);
+            astPath.node.arguments[0] = types.stringLiteral(depModuleName);
+          }
+        }
+      }
+    },
+    MemberExpression(astPath) {
+      if (astPath.node.property.name === "constructor" && !astPath.node.computed) {
+        const getTypeString = types.callExpression(
+          types.memberExpression(
+            types.callExpression(
+              types.memberExpression(
+                types.memberExpression(
+                  types.memberExpression(
+                    types.identifier("Object"),
+                    types.identifier("prototype")
+                  ),
+                  types.identifier("toString")
+                ),
+                types.identifier("call")
+              ),
+              [astPath.node.object]
+            ),
+            types.identifier("slice")
+          ),
+          [types.numericLiteral(8), types.numericLiteral(-1)]
+        );
+        astPath.replaceWith(getTypeString);
+      }
+    }
+  });
+  return babel.transformFromAstSync(wxsAst, "", {
+    comments: false
+  }).code;
+}
+function isWxsModuleByContent(moduleCode, modulePath = "") {
+  if (!moduleCode || typeof moduleCode !== "string") {
+    return false;
+  }
+  if (modulePath && isRegisteredWxsModule(modulePath)) {
+    return true;
+  }
+  return false;
+}
+function processWxsDependency(wxsFilePath, moduleName, scriptModule, workPath, filePath) {
+  if (!fs.existsSync(wxsFilePath)) {
+    console.warn(`[view] wxs 依赖文件不存在: ${wxsFilePath}`);
+    return;
+  }
+  if (scriptModule.find((sm) => sm.path === moduleName)) {
+    return;
+  }
+  const wxsContent = env.getContentByPath(wxsFilePath).trim();
+  if (!wxsContent) {
+    return;
+  }
+  const wxsCode = processWxsContent(wxsContent, wxsFilePath, scriptModule, workPath, filePath);
+  registerWxsModule(moduleName);
+  scriptModule.push({
+    path: moduleName,
+    code: wxsCode
+  });
+}
+function compileModuleWithAllWxs(module2, scriptRes, allScriptModules) {
+  const { tpl, instruction } = toCompileTemplate(false, module2.path, module2.usingComponents, module2.componentPlaceholder);
+  if (!tpl) {
+    return;
+  }
+  const mergedInstruction = {
+    ...instruction,
+    scriptModule: allScriptModules
+  };
+  const processedTpl = tpl.replace(/\bthis\./g, "_ctx.");
+  const tplCode = compilerSfc.compileTemplate({
+    source: processedTpl,
+    filename: module2.path,
+    id: `data-v-${module2.id}`,
+    scoped: true,
+    compilerOptions: {
+      prefixIdentifiers: true,
+      hoistStatic: false,
+      cacheHandlers: true,
+      scopeId: `data-v-${module2.id}`,
+      mode: "function",
+      inline: true
+    }
+  });
+  let tplComponents = "{";
+  for (const tm of mergedInstruction.templateModule) {
+    let { code: code2 } = compilerSfc.compileTemplate({
+      source: tm.tpl,
+      filename: tm.path,
+      id: `data-v-${module2.id}`,
+      scoped: true,
+      compilerOptions: {
+        prefixIdentifiers: true,
+        hoistStatic: false,
+        cacheHandlers: true,
+        scopeId: `data-v-${module2.id}`,
+        mode: "function",
+        inline: true
+      }
+    });
+    const ast = babel.parseSync(code2);
+    insertWxsToRenderAst(ast, allScriptModules, scriptRes);
+    code2 = babel.transformFromAstSync(ast, "", {
+      comments: false
+    }).code;
+    tplComponents += `'${tm.path}':${code2.replace(/;$/, "").replace(/^"use strict";\s*/, "")},`;
   }
+  tplComponents += "}";
+  const tplAst = babel.parseSync(tplCode.code);
+  insertWxsToRenderAst(tplAst, allScriptModules, scriptRes);
   const { code: transCode } = babel.transformFromAstSync(tplAst, "", {
     comments: false
   });
@@ -196,12 +508,19 @@ function compileModule(module2, isComponent, scriptRes) {
 		usingComponents: ${JSON.stringify(module2.usingComponents)},
 		tplComponents: ${tplComponents},
 		});`;
-  compileResCache.set(module2.path, code);
+  const cacheData = {
+    code,
+    instruction: mergedInstruction
+  };
+  compileResCache.set(module2.path, cacheData);
   scriptRes.set(module2.path, code);
 }
-function toCompileTemplate(isComponent, path, components, componentPlaceholder) {
+function processIncludedFileWxsDependencies(content, includePath, scriptModule, components) {
+  console.warn("[view]", `跳过被引入文件的组件 wxs 依赖处理: ${includePath}`);
+}
+function toCompileTemplate(isComponent, path2, components, componentPlaceholder) {
   const workPath = env.getWorkPath();
-  const fullPath = getViewPath(workPath, path);
+  const fullPath = getViewPath(workPath, path2);
   if (!fullPath) {
     return { tpl: void 0 };
   }
@@ -210,10 +529,20 @@ function toCompileTemplate(isComponent, path, components, componentPlaceholder)
     content = "<block></block>";
   } else {
     if (isComponent) {
-      content = `<wrapper>${content}</wrapper>`;
+      content = `<wrapper name="${path2}">${content}</wrapper>`;
+    } else {
+      const tempRoot = cheerio__namespace.load(content, {
+        xmlMode: true,
+        decodeEntities: false
+      });
+      const rootNodes = tempRoot.root().children().toArray().filter((node) => node.type !== "comment");
+      if (rootNodes.length > 1) {
+        content = `<view>${content}</view>`;
+      }
     }
   }
   const templateModule = [];
+  const scriptModule = [];
   const $ = cheerio__namespace.load(content, {
     xmlMode: true,
     decodeEntities: false
@@ -222,85 +551,74 @@ function toCompileTemplate(isComponent, path, components, componentPlaceholder)
   includeNodes.each((_, elem) => {
     const src = $(elem).attr("src");
     if (src) {
-      const includeContent = env.getContentByPath(env.getAbsolutePath(workPath, path, src)).trim();
+      const includeFullPath = env.getAbsolutePath(workPath, path2, src);
+      let includePath = includeFullPath.replace(workPath, "").replace(/\.(wxml|ddml)$/, "");
+      if (!includePath.startsWith("/")) {
+        includePath = "/" + includePath;
+      }
+      const includeContent = env.getContentByPath(includeFullPath).trim();
       if (includeContent) {
         const $includeContent = cheerio__namespace.load(includeContent, {
           xmlMode: true,
           decodeEntities: false
         });
+        transTagTemplate(
+          $includeContent,
+          templateModule,
+          includePath,
+          components
+        );
+        transTagWxs(
+          $includeContent,
+          scriptModule,
+          includePath
+        );
+        processIncludedFileWxsDependencies(includeContent, includePath);
         $includeContent("template").remove();
         $includeContent("wxs").remove();
         $includeContent("dds").remove();
-        $(elem).html($includeContent.html());
+        $(elem).replaceWith($includeContent.html());
+      } else {
+        $(elem).remove();
       }
+    } else {
+      $(elem).remove();
     }
   });
-  transTagTemplate($, templateModule, path, components);
+  transTagTemplate($, templateModule, path2, components);
+  transTagWxs($, scriptModule, path2);
   const importNodes = $("import");
   importNodes.each((_, elem) => {
     const src = $(elem).attr("src");
     if (src) {
-      const importContent = env.getContentByPath(env.getAbsolutePath(workPath, path, src)).trim();
+      const importFullPath = env.getAbsolutePath(workPath, path2, src);
+      let importPath = importFullPath.replace(workPath, "").replace(/\.(wxml|ddml)$/, "");
+      if (!importPath.startsWith("/")) {
+        importPath = "/" + importPath;
+      }
+      const importContent = env.getContentByPath(importFullPath).trim();
       if (importContent) {
+        const $$ = cheerio__namespace.load(importContent, {
+          xmlMode: true,
+          decodeEntities: false
+        });
         transTagTemplate(
-          cheerio__namespace.load(importContent, {
-            xmlMode: true,
-            decodeEntities: false
-          }),
+          $$,
           templateModule,
-          path,
+          path2,
           components
         );
+        transTagWxs(
+          $$,
+          scriptModule,
+          importPath
+        );
+        processIncludedFileWxsDependencies(importContent, importPath);
       }
     }
   });
   importNodes.remove();
-  const scriptModule = [];
-  let wxsNodes = $("wxs");
-  if (wxsNodes.length === 0) {
-    wxsNodes = $("dds");
-  }
-  wxsNodes.each((_, elem) => {
-    const smName = $(elem).attr("module");
-    if (smName) {
-      let wxsContent;
-      if (compileResCache.has(smName)) {
-        wxsContent = compileResCache.get(smName);
-      } else {
-        const src = $(elem).attr("src");
-        if (src) {
-          wxsContent = env.getContentByPath(env.getAbsolutePath(workPath, path, src)).trim();
-        } else {
-          wxsContent = $(elem).html();
-        }
-        const wxsAst = babel.parseSync(wxsContent);
-        traverse(wxsAst, {
-          CallExpression(path2) {
-            if (path2.node.callee.name === "getRegExp" || path2.node.callee.name === "getDate") {
-              const args = [];
-              for (let i = 0; i < path2.node.arguments.length; i++) {
-                args.push(path2.node.arguments[i]);
-              }
-              const newExpr = types.newExpression(types.identifier(path2.node.callee.name.substring(3)), args);
-              path2.replaceWith(newExpr);
-            }
-          }
-        });
-        wxsContent = babel.transformFromAstSync(wxsAst, "", {
-          comments: false
-        }).code;
-        compileResCache.set(smName, wxsContent);
-      }
-      if (wxsContent) {
-        scriptModule.push({
-          path: smName,
-          code: wxsContent
-        });
-      }
-    }
-  });
-  wxsNodes.remove();
-  transAsses($, $("image"), path);
+  transAsses($, $("image"), path2);
   const res = [];
   transHtmlTag($.html(), res, components);
   return {
@@ -311,17 +629,16 @@ function toCompileTemplate(isComponent, path, components, componentPlaceholder)
     }
   };
 }
-function transTagTemplate($, templateModule, path, components, componentPlaceholder) {
+function transTagTemplate($, templateModule, path2, components, componentPlaceholder) {
   const templateNodes = $("template[name]");
   templateNodes.each((_, elem) => {
     const name = $(elem).attr("name");
     const templateContent = $(elem);
-    templateContent.find("template").remove();
     templateContent.find("import").remove();
     templateContent.find("include").remove();
     templateContent.find("wxs").remove();
     templateContent.find("dds").remove();
-    transAsses($, templateContent.find("image"), path);
+    transAsses($, templateContent.find("image"), path2);
     const res = [];
     transHtmlTag(templateContent.html(), res, components);
     templateModule.push({
@@ -331,11 +648,11 @@ function transTagTemplate($, templateModule, path, components, componentPlacehol
   });
   templateNodes.remove();
 }
-function transAsses($, imageNodes, path) {
+function transAsses($, imageNodes, path2) {
   imageNodes.each((_, elem) => {
     const imgSrc = $(elem).attr("src").trim();
     if (!imgSrc.startsWith("{{")) {
-      $(elem).attr("src", env.collectAssets(env.getWorkPath(), path, imgSrc, env.getTargetPath(), env.getAppId()));
+      $(elem).attr("src", env.collectAssets(env.getWorkPath(), path2, imgSrc, env.getTargetPath(), env.getAppId()));
     }
   });
 }
@@ -377,20 +694,20 @@ function transTag(opts) {
     res = `dd-${tag}`;
   }
   let tagRes;
-  const propsAry = getProps(attrs, tag);
+  const propsAry = isStart ? getProps(attrs, tag) : [];
   const multipleSlots = attrs?.slot;
   if (attrs?.slot) {
-    const withVIf = [];
-    const withoutVIf = [];
-    for (let i = 0; i < propsAry.length; i++) {
-      const prop = propsAry[i];
-      if (prop.includes("v-if") || prop.includes("v-else-if") || prop.includes("v-else")) {
-        withVIf.push(prop);
-      } else {
-        withoutVIf.push(prop);
-      }
-    }
     if (isStart) {
+      const withVIf = [];
+      const withoutVIf = [];
+      for (let i = 0; i < propsAry.length; i++) {
+        const prop = propsAry[i];
+        if (prop.includes("v-if") || prop.includes("v-else-if") || prop.includes("v-else")) {
+          withVIf.push(prop);
+        } else {
+          withoutVIf.push(prop);
+        }
+      }
       tagRes = `<template ${`${withVIf.join(" ")}`} #${multipleSlots}><${res}${` ${withoutVIf.join(" ")}`}>`;
     } else {
       tagRes = `</${res}></template>`;
@@ -430,14 +747,7 @@ function getProps(attrs, tag) {
       });
     } else if (name.endsWith(":for-item") || name.endsWith(":for-index")) ;
     else if (name.endsWith(":key")) {
-      let tranValue;
-      if (/\*this/.test(value)) {
-        tranValue = JSON.stringify("item");
-      } else if (/item/.test(value)) {
-        tranValue = getForItemName(attrs);
-      } else {
-        tranValue = parseKeyExpression(value, getForItemName(attrs));
-      }
+      const tranValue = parseKeyExpression(value, getForItemName(attrs), getForIndexName(attrs));
       attrsList.push({
         name: ":key",
         value: tranValue
@@ -554,19 +864,37 @@ function generateVModelTemplate(expression) {
   }
   return updateExpression;
 }
-function parseKeyExpression(exp, itemName = "item") {
+function parseKeyExpression(exp, itemName = "item", indexName = "index") {
   exp = exp.trim();
+  if (/\*this/.test(exp) || /\*item/.test(exp)) {
+    return `${itemName}.toString()`;
+  }
   if (!exp.includes("{{")) {
-    return exp.startsWith(itemName) ? `'${exp}'` : `'${itemName}.${exp}'`;
+    if (/^-?\d+(\.\d+)?$/.test(exp)) {
+      return exp;
+    }
+    if (exp === indexName) {
+      return indexName;
+    }
+    return exp.startsWith(itemName) ? `${exp}` : `${itemName}.${exp}`;
   }
   if (exp.startsWith("{{") && exp.endsWith("}}")) {
     const content = exp.slice(2, -2).trim();
-    return content.startsWith(itemName) ? `'${content}'` : `'${itemName}.${content}'`;
+    if (content === "this") {
+      return `${itemName}.toString()`;
+    } else if (content === indexName) {
+      return indexName;
+    } else {
+      return content.startsWith(itemName) ? `${content}` : `${itemName}.${content}`;
+    }
   }
   const parts = exp.split(/(\{\{.*?\}\})/);
   const result = parts.map((part) => {
     if (part.startsWith("{{") && part.endsWith("}}")) {
       const content = part.slice(2, -2).trim();
+      if (content === indexName) {
+        return indexName;
+      }
       return content.startsWith(itemName) ? content : `${itemName}.${content}`;
     }
     return `'${part}'`;
@@ -672,12 +1000,186 @@ function parseBraceExp(exp) {
   }
   return group.join("").replace(/^\+|\+$/g, "");
 }
-const viewCompiler = {
-  splitWithBraces,
-  parseClassRules,
-  parseBraceExp,
-  parseKeyExpression,
-  compileML,
-  generateVModelTemplate
-};
-module.exports = viewCompiler;
+function transTagWxs($, scriptModule, filePath) {
+  let wxsNodes = $("wxs");
+  if (wxsNodes.length === 0) {
+    wxsNodes = $("dds");
+  }
+  wxsNodes.each((_, elem) => {
+    const smName = $(elem).attr("module");
+    if (smName) {
+      let wxsContent;
+      let uniqueModuleName = smName;
+      let cacheKey = smName;
+      const src = $(elem).attr("src");
+      let wxsFilePath = null;
+      const workPath = env.getWorkPath();
+      if (src) {
+        if (filePath.includes("/miniprogram_npm/")) {
+          const componentDir = filePath.split("/").slice(0, -1).join("/");
+          const componentFullPath = workPath + componentDir;
+          wxsFilePath = path.resolve(componentFullPath, src);
+        } else {
+          wxsFilePath = env.getAbsolutePath(workPath, filePath, src);
+        }
+        if (wxsFilePath) {
+          const relativePath = wxsFilePath.replace(workPath, "").replace(/\.wxs$/, "");
+          uniqueModuleName = relativePath.replace(/[\/\\@\-]/g, "_").replace(/^_/, "");
+          cacheKey = wxsFilePath;
+        }
+      }
+      if (compileResCache.has(cacheKey)) {
+        wxsContent = compileResCache.get(cacheKey);
+      } else {
+        if (src && wxsFilePath) {
+          if (fs.existsSync(wxsFilePath)) {
+            wxsContent = env.getContentByPath(wxsFilePath).trim();
+          } else {
+            console.warn(`[view] wxs 文件不存在: ${wxsFilePath}`);
+            return;
+          }
+        } else {
+          wxsContent = $(elem).html();
+        }
+        if (!wxsContent) {
+          return;
+        }
+        wxsContent = processWxsContent(wxsContent, wxsFilePath, scriptModule, workPath, filePath);
+        compileResCache.set(cacheKey, wxsContent);
+      }
+      if (wxsContent) {
+        registerWxsModule(uniqueModuleName);
+        scriptModule.push({
+          path: uniqueModuleName,
+          code: wxsContent,
+          originalName: smName
+          // 保存原始模块名用于模板中的引用
+        });
+      }
+    }
+  });
+  wxsNodes.remove();
+}
+function collectAllWxsModules(scriptRes, collectedPaths = /* @__PURE__ */ new Set(), scriptModule = [], maxDepth = 5) {
+  if (maxDepth <= 0) {
+    console.warn("[view]", "collectAllWxsModules 达到最大递归深度，停止处理");
+    return [];
+  }
+  const allWxsModules = [];
+  const workPath = env.getWorkPath();
+  for (const [modulePath, moduleCode] of scriptRes.entries()) {
+    if (collectedPaths.has(modulePath)) {
+      continue;
+    }
+    if (isWxsModuleByContent(moduleCode, modulePath)) {
+      collectedPaths.add(modulePath);
+      allWxsModules.push({
+        path: modulePath,
+        code: moduleCode
+      });
+      const dependencies = extractWxsDependencies(moduleCode);
+      for (const depPath of dependencies) {
+        if (!collectedPaths.has(depPath)) {
+          if (scriptRes.has(depPath)) {
+            const depModules = collectAllWxsModules(
+              /* @__PURE__ */ new Map([[depPath, scriptRes.get(depPath)]]),
+              collectedPaths,
+              scriptModule,
+              maxDepth - 1
+            );
+            allWxsModules.push(...depModules);
+          } else {
+            const loaded = loadWxsModule(depPath, workPath, scriptModule);
+            if (loaded) {
+              scriptRes.set(depPath, loaded.code);
+              allWxsModules.push(loaded);
+              collectedPaths.add(depPath);
+              const depModules = collectAllWxsModules(
+                /* @__PURE__ */ new Map([[depPath, loaded.code]]),
+                collectedPaths,
+                scriptModule,
+                maxDepth - 1
+              );
+              allWxsModules.push(...depModules);
+            }
+          }
+        }
+      }
+    }
+  }
+  return allWxsModules;
+}
+function loadWxsModule(modulePath, workPath, scriptModule) {
+  if (!modulePath.startsWith("miniprogram_npm__") || !modulePath.includes("_wxs_")) {
+    return null;
+  }
+  const wxsFilePath = wxsFilePathMap.get(modulePath);
+  if (!wxsFilePath) {
+    console.warn(`[view] 无法找到 wxs 模块文件: ${modulePath}`);
+    return null;
+  }
+  try {
+    const wxsContent = env.getContentByPath(wxsFilePath).trim();
+    if (!wxsContent) {
+      return null;
+    }
+    const processedContent = processWxsContent(wxsContent, wxsFilePath, scriptModule, workPath, "");
+    registerWxsModule(modulePath);
+    return {
+      path: modulePath,
+      code: processedContent
+    };
+  } catch (error) {
+    console.warn(`[view] 加载 wxs 模块失败: ${modulePath}`, error.message);
+    return null;
+  }
+}
+function extractWxsDependencies(moduleCode) {
+  const dependencies = [];
+  const requirePattern = /(?:require|_)\s*\(\s*["']([^"']+)["']\s*\)/g;
+  let match;
+  while ((match = requirePattern.exec(moduleCode)) !== null) {
+    const depPath = match[1];
+    if (depPath && !dependencies.includes(depPath)) {
+      dependencies.push(depPath);
+    }
+  }
+  return dependencies;
+}
+function insertWxsToRenderAst(ast, scriptModule, scriptRes) {
+  for (const sm of scriptModule) {
+    if (!scriptRes.has(sm.path)) {
+      scriptRes.set(sm.path, sm.code);
+    }
+    const templatePropertyName = sm.originalName || sm.path;
+    const requireModuleName = sm.path;
+    const assignmentExpression = types.assignmentExpression(
+      "=",
+      // 创建赋值表达式
+      types.memberExpression(
+        types.identifier("_ctx"),
+        // 对象标识符
+        types.identifier(templatePropertyName),
+        // 使用原始模块名作为属性名
+        false
+        // 是否是计算属性
+      ),
+      // 创建require调用表达式
+      types.callExpression(
+        types.identifier("require"),
+        // 函数标识符
+        [types.stringLiteral(requireModuleName)]
+        // 使用唯一模块名作为 require 参数
+      )
+    );
+    const expressionStatement = types.expressionStatement(assignmentExpression);
+    ast.program.body[0].expression.body.body.unshift(expressionStatement);
+  }
+}
+exports.compileML = compileML;
+exports.generateVModelTemplate = generateVModelTemplate;
+exports.parseBraceExp = parseBraceExp;
+exports.parseClassRules = parseClassRules;
+exports.parseKeyExpression = parseKeyExpression;
+exports.processWxsContent = processWxsContent;
+exports.splitWithBraces = splitWithBraces;