weapp-tailwindcss 4.10.2 → 4.11.0-alpha.0

package/dist/{chunk-WJU62RPV.mjs → chunk-QX2A7SBB.mjs}

@@ -12,8 +12,9 @@ import {
 } from "./chunk-RRHPTTCP.mjs";
 import {
   setupPatchRecorder
-} from "./chunk-BZCCVPSU.mjs";
+} from "./chunk-EOK3NZVC.mjs";
 import {
+  babelParse,
   collectRuntimeClassSet,
   createAttributeMatcher,
   createDebug,
@@ -23,8 +24,9 @@ import {
   refreshTailwindRuntimeState,
   replaceWxml,
   toCustomAttributesEntities,
+  traverse,
   vitePluginName
-} from "./chunk-MPVAZKRB.mjs";
+} from "./chunk-FMWKBZWX.mjs";
 import {
   resolveUniUtsPlatform
 } from "./chunk-OOHJLO5M.mjs";
@@ -38,12 +40,12 @@ import postcssHtmlTransform from "@weapp-tailwindcss/postcss/html-transform";
 import { NodeTypes } from "@vue/compiler-dom";
 import { parse } from "@vue/compiler-sfc";
 import MagicString from "magic-string";
-function traverse(node, visitor) {
+function traverse2(node, visitor) {
   visitor(node);
   if (Array.isArray(node.children)) {
     for (const child of node.children) {
       if (child && typeof child === "object" && "type" in child) {
-        traverse(child, visitor);
+        traverse2(child, visitor);
       }
     }
   }
@@ -91,8 +93,9 @@ var defaultCreateJsHandlerOptions = {
     ]
   }
 };
+var UVUE_NVUE_RE = /\.(?:uvue|nvue)(?:\?.*)?$/;
 function transformUVue(code, id, jsHandler, runtimeSet, options = {}) {
-  if (!/\.(?:uvue|nvue)(?:\?.*)?$/.test(id)) {
+  if (!UVUE_NVUE_RE.test(id)) {
     return;
   }
   const { customAttributesEntities, disabledDefaultTemplateHandler = false } = options;
@@ -101,7 +104,7 @@ function transformUVue(code, id, jsHandler, runtimeSet, options = {}) {
   const { descriptor, errors } = parse(code);
   if (errors.length === 0) {
     if (descriptor.template?.ast) {
-      traverse(descriptor.template.ast, (node) => {
+      traverse2(descriptor.template.ast, (node) => {
         if (node.type !== NodeTypes.ELEMENT) {
           return;
         }
@@ -223,16 +226,20 @@ async function formatPostcssSourceMap(rawMap, file) {
 
 // src/uni-app-x/vite.ts
 var preprocessorLangs = /* @__PURE__ */ new Set(["scss", "sass", "less", "styl", "stylus"]);
+var INLINE_LANG_RE = /lang\.([a-z]+)/i;
+var PREPROCESSOR_EXT_RE = /\.(?:scss|sass|less|styl|stylus)(?:\?|$)/i;
+var UVUE_NVUE_QUERY_RE = /\.(?:uvue|nvue)(?:\?.*)?$/;
+var UVUE_NVUE_RE2 = /\.(?:uvue|nvue)$/;
 function isPreprocessorRequest(id, lang) {
   const normalizedLang = lang?.toLowerCase();
   if (normalizedLang && preprocessorLangs.has(normalizedLang)) {
     return true;
   }
-  const inlineLangMatch = id.match(/lang\.([a-z]+)/i);
+  const inlineLangMatch = id.match(INLINE_LANG_RE);
   if (inlineLangMatch && preprocessorLangs.has(inlineLangMatch[1].toLowerCase())) {
     return true;
   }
-  return /\.(?:scss|sass|less|styl|stylus)(?:\?|$)/i.test(id);
+  return PREPROCESSOR_EXT_RE.test(id);
 }
 function createUniAppXPlugins(options) {
   const {
@@ -248,24 +255,31 @@ function createUniAppXPlugins(options) {
     getResolvedConfig
   } = options;
   const isIosPlatform = providedIosPlatform ?? resolveUniUtsPlatform().isAppIos;
+  const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
   async function transformStyle(code, id, query) {
     const parsed = query ?? parseVueRequest(id).query;
     if (isCSSRequest(id) || parsed.vue && parsed.type === "style") {
-      const postcssResult = await styleHandler(code, {
-        isMainChunk: mainCssChunkMatcher(id, appType),
-        postcssOptions: {
-          options: {
-            from: id,
-            map: {
-              inline: false,
-              annotation: false,
-              // PostCSS 可能返回虚拟文件，因此需要启用这一项以获取源内容
-              sourcesContent: true
-              // 若上游预处理器已经生成 source map，sources 中可能出现重复条目
+      const cacheKey = `${mainCssChunkMatcher(id, appType) ? "1" : "0"}:${id}`;
+      let styleHandlerOptions = cssHandlerOptionsCache.get(cacheKey);
+      if (!styleHandlerOptions) {
+        styleHandlerOptions = {
+          isMainChunk: mainCssChunkMatcher(id, appType),
+          postcssOptions: {
+            options: {
+              from: id,
+              map: {
+                inline: false,
+                annotation: false,
+                // PostCSS 可能返回虚拟文件，因此需要启用这一项以获取源内容
+                sourcesContent: true
+                // 若上游预处理器已经生成 source map，sources 中可能出现重复条目
+              }
             }
           }
-        }
-      });
+        };
+        cssHandlerOptionsCache.set(cacheKey, styleHandlerOptions);
+      }
+      const postcssResult = await styleHandler(code, styleHandlerOptions);
       const rawPostcssMap = postcssResult.map.toJSON();
       const postcssMap = await formatPostcssSourceMap(
         rawPostcssMap,
@@ -305,7 +319,7 @@ function createUniAppXPlugins(options) {
       await ensureRuntimeClassSet(true);
     },
     async transform(code, id) {
-      if (!/\.(?:uvue|nvue)(?:\?.*)?$/.test(id)) {
+      if (!UVUE_NVUE_QUERY_RE.test(id)) {
         return;
       }
       const resolvedConfig = getResolvedConfig();
@@ -328,7 +342,7 @@ function createUniAppXPlugins(options) {
       if (resolvedConfig?.command !== "serve") {
         return;
       }
-      if (!/\.(?:uvue|nvue)$/.test(ctx.file)) {
+      if (!UVUE_NVUE_RE2.test(ctx.file)) {
         return;
       }
       await ensureRuntimeClassSet(true);
@@ -338,7 +352,7 @@ function createUniAppXPlugins(options) {
       if (resolvedConfig?.command !== "build" || !resolvedConfig.build?.watch) {
         return;
       }
-      if (!/\.(?:uvue|nvue)(?:\?.*)?$/.test(id)) {
+      if (!UVUE_NVUE_QUERY_RE.test(id)) {
         return;
       }
       await ensureRuntimeClassSet(true);
@@ -470,46 +484,116 @@ function applyLinkedResults(linked, entries, onLinkedUpdate, onApplied) {
   }
 }
 
-// src/bundlers/vite/js-precheck.ts
-var FAST_JS_TRANSFORM_HINT_RE = /className\b|class\s*=|classList\.|\b(?:twMerge|clsx|classnames|cn|cva)\b|\[["'`]class["'`]\]|text-\[|bg-\[|\b(?:[whpm]|px|py|mx|my|rounded|flex|grid|gap)-/;
-var DEPENDENCY_HINT_RE = /\bimport\s*[("'`{*]|\brequire\s*\(|\bexport\s+\*\s+from\s+["'`]|\bexport\s*\{[^}]*\}\s*from\s+["'`]/;
-function shouldSkipViteJsTransform(rawSource, options) {
-  if (!rawSource) {
-    return true;
-  }
-  if (options?.alwaysEscape) {
-    return false;
+// src/bundlers/vite/runtime-affecting-signature.ts
+import { Parser } from "htmlparser2";
+function createHtmlRuntimeAffectingSignature(source) {
+  try {
+    const parts = [];
+    const parser = new Parser(
+      {
+        onattribute(name, value) {
+          parts.push(`a:${name}=${value}`);
+        },
+        oncomment(data) {
+          parts.push(`c:${data}`);
+        },
+        ontext(data) {
+          const value = data.trim();
+          if (value.length > 0) {
+            parts.push(`t:${value}`);
+          }
+        }
+      },
+      {
+        xmlMode: true
+      }
+    );
+    parser.write(source);
+    parser.end();
+    return parts.join("\n");
+  } catch {
+    return source;
   }
-  if (options?.moduleSpecifierReplacements && Object.keys(options.moduleSpecifierReplacements).length > 0) {
-    return false;
+}
+function createJsRuntimeAffectingSignature(source) {
+  try {
+    const ast = babelParse(source, {
+      cache: true,
+      cacheKey: "vite-runtime-affecting:unambiguous",
+      plugins: ["jsx", "typescript"],
+      sourceType: "unambiguous"
+    });
+    const parts = [];
+    traverse(ast, {
+      noScope: true,
+      StringLiteral(path4) {
+        parts.push(`s:${path4.node.value}`);
+      },
+      TemplateElement(path4) {
+        parts.push(`t:${path4.node.value.raw}`);
+      },
+      JSXText(path4) {
+        const value = path4.node.value.trim();
+        if (value.length > 0) {
+          parts.push(`x:${value}`);
+        }
+      }
+    });
+    const comments = ast.comments;
+    if (Array.isArray(comments)) {
+      for (const comment of comments) {
+        if (typeof comment?.value === "string" && comment.value.length > 0) {
+          parts.push(`c:${comment.value}`);
+        }
+      }
+    }
+    return parts.join("\n");
+  } catch {
+    return source;
   }
-  if (options?.wrapExpression) {
-    return false;
+}
+function createRuntimeAffectingSourceSignature(source, type) {
+  if (type === "html") {
+    return createHtmlRuntimeAffectingSignature(source);
   }
-  if (DEPENDENCY_HINT_RE.test(rawSource)) {
-    return false;
+  if (type === "js") {
+    return createJsRuntimeAffectingSignature(source);
   }
-  return !FAST_JS_TRANSFORM_HINT_RE.test(rawSource);
+  return source;
 }
 
-// src/bundlers/vite/generate-bundle.ts
-function createEmptyMetric() {
+// src/bundlers/vite/bundle-state.ts
+function createBundleBuildState() {
   return {
-    total: 0,
-    transformed: 0,
-    cacheHits: 0,
-    elapsed: 0
+    iteration: 0,
+    sourceHashByFile: /* @__PURE__ */ new Map(),
+    runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+    linkedByEntry: /* @__PURE__ */ new Map(),
+    dependentsByLinkedFile: /* @__PURE__ */ new Map()
   };
 }
-function createEmptyMetrics() {
+function createChangedByType() {
   return {
-    runtimeSet: 0,
-    html: createEmptyMetric(),
-    js: createEmptyMetric(),
-    css: createEmptyMetric()
+    html: /* @__PURE__ */ new Set(),
+    js: /* @__PURE__ */ new Set(),
+    css: /* @__PURE__ */ new Set(),
+    other: /* @__PURE__ */ new Set()
   };
 }
-function classifyEntry(file, opts) {
+function createProcessFiles() {
+  return {
+    html: /* @__PURE__ */ new Set(),
+    js: /* @__PURE__ */ new Set(),
+    css: /* @__PURE__ */ new Set()
+  };
+}
+function readEntrySource(output) {
+  if (output.type === "chunk") {
+    return output.code;
+  }
+  return output.source.toString();
+}
+function classifyBundleEntry(file, opts) {
   if (opts.cssMatcher(file)) {
     return "css";
   }
@@ -521,84 +605,69 @@ function classifyEntry(file, opts) {
   }
   return "other";
 }
-function readEntrySource(output) {
-  if (output.type === "chunk") {
-    return output.code;
+function collectJsEntries(fileName, output, outDir, store) {
+  const entry = { fileName, output };
+  if (!isJavaScriptEntry(entry)) {
+    return;
   }
-  return output.source.toString();
+  const absolute = toAbsoluteOutputPath(fileName, outDir);
+  store.set(absolute, entry);
 }
-function toJsAbsoluteFilename(file, outDir) {
-  return toAbsoluteOutputPath(file, outDir);
+function markProcessFile(type, file, processFiles) {
+  if (type === "html" || type === "js" || type === "css") {
+    processFiles[type].add(file);
+  }
 }
-function computeDirtyEntries(entries, opts, state) {
-  const nextSourceHashByFile = /* @__PURE__ */ new Map();
-  const changedByType = {
-    html: /* @__PURE__ */ new Set(),
-    js: /* @__PURE__ */ new Set(),
-    css: /* @__PURE__ */ new Set(),
-    other: /* @__PURE__ */ new Set()
-  };
-  for (const [file, output] of entries) {
-    const type = classifyEntry(file, opts);
+function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false) {
+  const sourceHashByFile = /* @__PURE__ */ new Map();
+  const runtimeAffectingHashByFile = /* @__PURE__ */ new Map();
+  const changedByType = createChangedByType();
+  const runtimeAffectingChangedByType = createChangedByType();
+  const processFiles = createProcessFiles();
+  const linkedImpactsByEntry = /* @__PURE__ */ new Map();
+  const jsEntries = /* @__PURE__ */ new Map();
+  const entries = [];
+  const firstRun = state.linkedByEntry.size === 0;
+  for (const [file, output] of Object.entries(bundle)) {
+    const type = classifyBundleEntry(file, opts);
     const source = readEntrySource(output);
     const hash = opts.cache.computeHash(source);
-    nextSourceHashByFile.set(file, hash);
-    const previousHash = state.previousSourceHashByFile.get(file);
-    if (previousHash == null || previousHash !== hash) {
+    sourceHashByFile.set(file, hash);
+    const runtimeAffectingSignature = createRuntimeAffectingSourceSignature(source, type);
+    const runtimeAffectingHash = opts.cache.computeHash(runtimeAffectingSignature);
+    runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
+    const previousHash = state.sourceHashByFile.get(file);
+    const changed = previousHash == null || previousHash !== hash;
+    if (changed) {
       changedByType[type].add(file);
     }
-  }
-  return {
-    sourceHashByFile: nextSourceHashByFile,
-    changedByType
-  };
-}
-function buildProcessSets(entries, opts, changedByType, previousLinkedByEntry, forceAll = false) {
-  const processFiles = {
-    html: /* @__PURE__ */ new Set(),
-    js: /* @__PURE__ */ new Set(),
-    css: /* @__PURE__ */ new Set()
-  };
-  const linkedImpactsByEntry = /* @__PURE__ */ new Map();
-  if (forceAll) {
-    for (const [file] of entries) {
-      const type = classifyEntry(file, opts);
-      if (type === "html" || type === "js" || type === "css") {
-        processFiles[type].add(file);
-      }
-    }
-    return {
-      files: processFiles,
-      linkedImpactsByEntry
-    };
-  }
-  const firstRun = previousLinkedByEntry.size === 0;
-  if (firstRun) {
-    for (const [file] of entries) {
-      const type = classifyEntry(file, opts);
-      if (type === "html" || type === "js" || type === "css") {
-        processFiles[type].add(file);
-      }
+    const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
+    const runtimeAffectingChanged = previousRuntimeAffectingHash == null || previousRuntimeAffectingHash !== runtimeAffectingHash;
+    if (runtimeAffectingChanged) {
+      runtimeAffectingChangedByType[type].add(file);
     }
-    return {
-      files: processFiles,
-      linkedImpactsByEntry
-    };
-  }
-  for (const [file] of entries) {
-    if (classifyEntry(file, opts) === "html") {
+    if (forceAll || firstRun) {
+      markProcessFile(type, file, processFiles);
+    } else if (type === "html") {
       processFiles.html.add(file);
+    } else if (changed && (type === "js" || type === "css")) {
+      processFiles[type].add(file);
     }
+    collectJsEntries(file, output, outDir, jsEntries);
+    entries.push({
+      file,
+      output,
+      source,
+      type
+    });
   }
-  for (const file of changedByType.css) {
-    processFiles.css.add(file);
-  }
-  for (const file of changedByType.js) {
-    processFiles.js.add(file);
-  }
-  for (const changedFile of changedByType.js) {
-    for (const [entryFile, linkedFiles] of previousLinkedByEntry.entries()) {
-      if (linkedFiles.has(changedFile)) {
+  if (!forceAll && !firstRun) {
+    for (const changedFile of changedByType.js) {
+      const dependents = state.dependentsByLinkedFile.get(changedFile);
+      if (!dependents) {
+        continue;
+      }
+      for (const entryFile of dependents) {
         processFiles.js.add(entryFile);
         let impacts = linkedImpactsByEntry.get(entryFile);
         if (!impacts) {
@@ -610,10 +679,87 @@ function buildProcessSets(entries, opts, changedByType, previousLinkedByEntry, f
     }
   }
   return {
-    files: processFiles,
+    entries,
+    jsEntries,
+    sourceHashByFile,
+    runtimeAffectingHashByFile,
+    changedByType,
+    runtimeAffectingChangedByType,
+    processFiles,
     linkedImpactsByEntry
   };
 }
+function invertLinkedByEntry(linkedByEntry) {
+  const dependentsByLinkedFile = /* @__PURE__ */ new Map();
+  for (const [entryFile, linkedFiles] of linkedByEntry.entries()) {
+    for (const linkedFile of linkedFiles) {
+      let dependents = dependentsByLinkedFile.get(linkedFile);
+      if (!dependents) {
+        dependents = /* @__PURE__ */ new Set();
+        dependentsByLinkedFile.set(linkedFile, dependents);
+      }
+      dependents.add(entryFile);
+    }
+  }
+  return dependentsByLinkedFile;
+}
+function updateBundleBuildState(state, snapshot, linkedByEntry) {
+  state.iteration += 1;
+  state.sourceHashByFile = snapshot.sourceHashByFile;
+  state.runtimeAffectingHashByFile = snapshot.runtimeAffectingHashByFile;
+  state.linkedByEntry = linkedByEntry;
+  state.dependentsByLinkedFile = invertLinkedByEntry(linkedByEntry);
+}
+
+// src/bundlers/vite/js-precheck.ts
+var FAST_JS_TRANSFORM_HINT_RE = /className\b|class\s*=|classList\.|\b(?:twMerge|clsx|classnames|cn|cva)\b|\[["'`]class["'`]\]|text-\[|bg-\[|\b(?:[whpm]|px|py|mx|my|rounded|flex|grid|gap)-/;
+var DEPENDENCY_HINT_RE = /\bimport\s*[("'`{*]|\brequire\s*\(|\bexport\s+\*\s+from\s+["'`]|\bexport\s*\{[^}]*\}\s*from\s+["'`]/;
+function shouldSkipViteJsTransform(rawSource, options) {
+  if (!rawSource) {
+    return true;
+  }
+  if (options?.alwaysEscape) {
+    return false;
+  }
+  if (options?.moduleSpecifierReplacements && Object.keys(options.moduleSpecifierReplacements).length > 0) {
+    return false;
+  }
+  if (options?.wrapExpression) {
+    return false;
+  }
+  if (DEPENDENCY_HINT_RE.test(rawSource)) {
+    return false;
+  }
+  return !FAST_JS_TRANSFORM_HINT_RE.test(rawSource);
+}
+
+// src/bundlers/vite/generate-bundle.ts
+function formatDebugFileList(files, limit = 8) {
+  if (files.size === 0) {
+    return "-";
+  }
+  const sorted = [...files].sort();
+  if (sorted.length <= limit) {
+    return sorted.join(",");
+  }
+  return `${sorted.slice(0, limit).join(",")},...(+${sorted.length - limit})`;
+}
+function createEmptyMetric() {
+  return {
+    total: 0,
+    transformed: 0,
+    cacheHits: 0,
+    elapsed: 0
+  };
+}
+function createEmptyMetrics() {
+  return {
+    runtimeSet: 0,
+    html: createEmptyMetric(),
+    js: createEmptyMetric(),
+    css: createEmptyMetric()
+  };
+}
 function measureElapsed(start) {
   return performance.now() - start;
 }
@@ -668,17 +814,8 @@ function hasRuntimeAffectingSourceChanges(changedByType) {
   return changedByType.html.size > 0 || changedByType.js.size > 0;
 }
 function createGenerateBundleHook(context) {
-  const state = {
-    iteration: 0,
-    previousSourceHashByFile: /* @__PURE__ */ new Map(),
-    previousLinkedByEntry: /* @__PURE__ */ new Map(),
-    changedByType: {
-      html: /* @__PURE__ */ new Set(),
-      js: /* @__PURE__ */ new Set(),
-      css: /* @__PURE__ */ new Set(),
-      other: /* @__PURE__ */ new Set()
-    }
-  };
+  const state = createBundleBuildState();
+  const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
   return async function generateBundle(_opt, bundle) {
     const {
       opts,
@@ -699,6 +836,26 @@ function createGenerateBundleHook(context) {
       jsHandler,
       uniAppX
     } = opts;
+    const getCssHandlerOptions = (file) => {
+      const majorVersion = runtimeState.twPatcher.majorVersion;
+      const isMainChunk = mainCssChunkMatcher(file, appType);
+      const cacheKey = `${majorVersion ?? "unknown"}:${isMainChunk ? "1" : "0"}:${file}`;
+      const cached = cssHandlerOptionsCache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+      const created = {
+        isMainChunk,
+        postcssOptions: {
+          options: {
+            from: file
+          }
+        },
+        majorVersion
+      };
+      cssHandlerOptionsCache.set(cacheKey, created);
+      return created;
+    };
     await runtimeState.patchPromise;
     debug2("start");
     onStart();
@@ -707,32 +864,48 @@ function createGenerateBundleHook(context) {
     const disableDirtyOptimization = process2.env.WEAPP_TW_VITE_DISABLE_DIRTY === "1";
     const disableJsPrecheck = process2.env.WEAPP_TW_VITE_DISABLE_JS_PRECHECK === "1";
     const debugCssDiff = process2.env.WEAPP_TW_VITE_DEBUG_CSS_DIFF === "1";
-    const entries = Object.entries(bundle);
-    const dirtyEntries = computeDirtyEntries(entries, opts, state);
-    const forceRuntimeRefreshBySource = hasRuntimeAffectingSourceChanges(dirtyEntries.changedByType);
-    const forceRuntimeRefresh = forceRuntimeRefreshByEnv || forceRuntimeRefreshBySource;
-    const processSets = buildProcessSets(entries, opts, dirtyEntries.changedByType, state.previousLinkedByEntry, disableDirtyOptimization);
-    const processFiles = processSets.files;
     const resolvedConfig = getResolvedConfig();
     const rootDir = resolvedConfig?.root ? path2.resolve(resolvedConfig.root) : process2.cwd();
     const outDir = resolvedConfig?.build?.outDir ? path2.resolve(rootDir, resolvedConfig.build.outDir) : rootDir;
-    const jsEntries = /* @__PURE__ */ new Map();
-    for (const [fileName, output] of entries) {
-      const entry = { fileName, output };
-      if (isJavaScriptEntry(entry)) {
-        const absolute = toJsAbsoluteFilename(fileName, outDir);
-        jsEntries.set(absolute, entry);
-      }
-    }
+    const snapshot = buildBundleSnapshot(bundle, opts, outDir, state, disableDirtyOptimization);
+    const forceRuntimeRefreshBySource = hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
+    const forceRuntimeRefresh = forceRuntimeRefreshByEnv || forceRuntimeRefreshBySource;
+    const processFiles = snapshot.processFiles;
+    debug2(
+      "dirty iteration=%d html=%d[%s] js=%d[%s] css=%d[%s] other=%d[%s]",
+      state.iteration + 1,
+      snapshot.changedByType.html.size,
+      formatDebugFileList(snapshot.changedByType.html),
+      snapshot.changedByType.js.size,
+      formatDebugFileList(snapshot.changedByType.js),
+      snapshot.changedByType.css.size,
+      formatDebugFileList(snapshot.changedByType.css),
+      snapshot.changedByType.other.size,
+      formatDebugFileList(snapshot.changedByType.other)
+    );
+    debug2(
+      "process iteration=%d html=%d[%s] js=%d[%s] css=%d[%s]",
+      state.iteration + 1,
+      processFiles.html.size,
+      formatDebugFileList(processFiles.html),
+      processFiles.js.size,
+      formatDebugFileList(processFiles.js),
+      processFiles.css.size,
+      formatDebugFileList(processFiles.css)
+    );
+    const jsEntries = snapshot.jsEntries;
     const moduleGraphOptions = createBundleModuleGraphOptions(outDir, jsEntries);
     const runtimeStart = performance.now();
     const runtime = await ensureRuntimeClassSet(forceRuntimeRefresh);
+    const defaultTemplateHandlerOptions = {
+      runtimeSet: runtime
+    };
     metrics.runtimeSet = measureElapsed(runtimeStart);
     if (forceRuntimeRefreshBySource) {
       debug2(
         "runtimeSet forced refresh due to source changes: html=%d js=%d",
-        dirtyEntries.changedByType.html.size,
-        dirtyEntries.changedByType.js.size
+        snapshot.runtimeAffectingChangedByType.html.size,
+        snapshot.runtimeAffectingChangedByType.js.size
       );
     }
     debug2("get runtimeSet, class count: %d", runtime.size);
@@ -767,14 +940,14 @@ function createGenerateBundleHook(context) {
     const linkedByEntry = /* @__PURE__ */ new Map();
     const tasks = [];
     const jsTaskFactories = [];
-    for (const [file, originalSource] of entries) {
-      const type = classifyEntry(file, opts);
+    for (const entry of snapshot.entries) {
+      const { file, output: originalSource, source: originalEntrySource, type } = entry;
       if (type === "html" && originalSource.type === "asset") {
         metrics.html.total++;
         if (!processFiles.html.has(file)) {
           continue;
         }
-        const rawSource = originalSource.source.toString();
+        const rawSource = originalEntrySource;
         tasks.push(
           processCachedTask({
             cache,
@@ -790,9 +963,7 @@ function createGenerateBundleHook(context) {
             },
             async transform() {
               const start = performance.now();
-              const transformed = await templateHandler(rawSource, {
-                runtimeSet: runtime
-              });
+              const transformed = await templateHandler(rawSource, defaultTemplateHandlerOptions);
               metrics.html.elapsed += measureElapsed(start);
               metrics.html.transformed++;
               onUpdate(file, rawSource, transformed);
@@ -807,7 +978,7 @@ function createGenerateBundleHook(context) {
       }
       if (type === "css" && originalSource.type === "asset") {
         metrics.css.total++;
-        const rawSource = originalSource.source.toString();
+        const rawSource = originalEntrySource;
         tasks.push(
           processCachedTask({
             cache,
@@ -824,15 +995,7 @@ function createGenerateBundleHook(context) {
             async transform() {
               const start = performance.now();
               await runtimeState.patchPromise;
-              const { css } = await styleHandler(rawSource, {
-                isMainChunk: mainCssChunkMatcher(originalSource.fileName, appType),
-                postcssOptions: {
-                  options: {
-                    from: file
-                  }
-                },
-                majorVersion: runtimeState.twPatcher.majorVersion
-              });
+              const { css } = await styleHandler(rawSource, getCssHandlerOptions(file));
               if (debugCssDiff) {
                 debug2("css diff %s: %s", file, summarizeStringDiff(rawSource, css));
               }
@@ -852,19 +1015,20 @@ function createGenerateBundleHook(context) {
         continue;
       }
       metrics.js.total++;
-      if (!processFiles.js.has(file)) {
-        continue;
+      const shouldTransformJs = processFiles.js.has(file);
+      if (!shouldTransformJs) {
+        debug2("js skip transform (clean), replay cache: %s", file);
       }
       if (originalSource.type === "chunk") {
-        const absoluteFile = toJsAbsoluteFilename(file, outDir);
-        const initialRawSource = originalSource.code;
+        const absoluteFile = path2.resolve(outDir, file);
+        const initialRawSource = originalEntrySource;
         const linkedSet = /* @__PURE__ */ new Set();
         linkedByEntry.set(file, linkedSet);
         jsTaskFactories.push(async () => {
           const linkedImpactSignature = createLinkedImpactSignature(
             file,
-            processSets.linkedImpactsByEntry,
-            dirtyEntries.sourceHashByFile
+            snapshot.linkedImpactsByEntry,
+            snapshot.sourceHashByFile
           );
           const hashSalt = createJsHashSalt(runtimeSignature, linkedImpactSignature);
           await processCachedTask({
@@ -883,6 +1047,9 @@ function createGenerateBundleHook(context) {
             async transform() {
               const start = performance.now();
               const rawSource = originalSource.code;
+              if (!shouldTransformJs) {
+                debug2("js cache replay miss, fallback transform: %s", file);
+              }
               const handlerOptions = createHandlerOptions(absoluteFile);
               if (!disableJsPrecheck && shouldSkipViteJsTransform(rawSource, handlerOptions)) {
                 metrics.js.elapsed += measureElapsed(start);
@@ -937,8 +1104,8 @@ function createGenerateBundleHook(context) {
               runtimeSignature,
               createLinkedImpactSignature(
                 file,
-                processSets.linkedImpactsByEntry,
-                dirtyEntries.sourceHashByFile
+                snapshot.linkedImpactsByEntry,
+                snapshot.sourceHashByFile
               )
             ),
             createHandlerOptions,
@@ -952,8 +1119,15 @@ function createGenerateBundleHook(context) {
         );
         jsTaskFactories.push(async () => {
           const start = performance.now();
-          const currentSource = originalSource.source.toString();
-          const absoluteFile = toJsAbsoluteFilename(file, outDir);
+          if (!shouldTransformJs) {
+            debug2("js skip transform (clean, uni-app-x), replay cache: %s", file);
+            await factory();
+            metrics.js.elapsed += measureElapsed(start);
+            metrics.js.transformed++;
+            return;
+          }
+          const currentSource = originalEntrySource;
+          const absoluteFile = path2.resolve(outDir, file);
           const precheckOptions = createHandlerOptions(absoluteFile, {
             uniAppX: uniAppX ?? true,
             babelParserOptions: {
@@ -977,20 +1151,7 @@ function createGenerateBundleHook(context) {
     for (const apply of pendingLinkedUpdates) {
       apply();
     }
-    state.iteration += 1;
-    state.previousSourceHashByFile = dirtyEntries.sourceHashByFile;
-    state.changedByType = dirtyEntries.changedByType;
-    const nextLinkedByEntry = new Map(state.previousLinkedByEntry);
-    for (const [entryFile, linkedFiles] of linkedByEntry.entries()) {
-      nextLinkedByEntry.set(entryFile, linkedFiles);
-    }
-    for (const entryFile of [...nextLinkedByEntry.keys()]) {
-      const exists = entries.some(([fileName]) => fileName === entryFile);
-      if (!exists) {
-        nextLinkedByEntry.delete(entryFile);
-      }
-    }
-    state.previousLinkedByEntry = nextLinkedByEntry;
+    updateBundleBuildState(state, snapshot, linkedByEntry);
     debug2(
       "metrics iteration=%d runtime=%sms html(total=%d transform=%d hit=%d rate=%s elapsed=%sms) js(total=%d transform=%d hit=%d rate=%s elapsed=%sms) css(total=%d transform=%d hit=%d rate=%s elapsed=%sms)",
       state.iteration,
@@ -1083,7 +1244,7 @@ var debug = createDebug();
 var weappTailwindcssPackageDir = resolvePackageDir("weapp-tailwindcss");
 var weappTailwindcssDirPosix = slash(weappTailwindcssPackageDir);
 function UnifiedViteWeappTailwindcssPlugin(options = {}) {
-  const rewriteCssImportsSpecified = Object.prototype.hasOwnProperty.call(options, "rewriteCssImports");
+  const rewriteCssImportsSpecified = Object.hasOwn(options, "rewriteCssImports");
   const hasExplicitTailwindcssBasedir = typeof options.tailwindcssBasedir === "string" && options.tailwindcssBasedir.trim().length > 0;
   const opts = getCompilerContext(options);
   const {
@@ -1218,12 +1379,13 @@ function UnifiedViteWeappTailwindcssPlugin(options = {}) {
           await refreshRuntimeState(true);
         }
         if (typeof config.css.postcss === "object" && Array.isArray(config.css.postcss.plugins)) {
-          const idx = config.css.postcss.plugins.findIndex((x) => (
+          const postcssPlugins = config.css.postcss.plugins;
+          const idx = postcssPlugins.findIndex((x) => (
             // @ts-ignore
             x.postcssPlugin === "postcss-html-transform"
           ));
           if (idx > -1) {
-            config.css.postcss.plugins.splice(idx, 1, postcssHtmlTransform());
+            postcssPlugins.splice(idx, 1, postcssHtmlTransform());
             debug("remove postcss-html-transform plugin from vite config");
           }
         }