weapp-tailwindcss 4.4.0 → 4.5.0-alpha.0

package/dist/chunk-34T2BFTJ.mjs

@@ -0,0 +1,59 @@
+// src/bundlers/shared/module-graph.ts
+import path from "path";
+var QUERY_HASH_RE = /[?#].*$/u;
+var PROTOCOL_RE = /^[a-z][a-z+.-]*:/iu;
+var VIRTUAL_PREFIX = "\0";
+var JS_EXTENSIONS = [".js", ".mjs", ".cjs"];
+function stripQueryAndHash(specifier) {
+  return specifier.replace(QUERY_HASH_RE, "");
+}
+function isResolvableSpecifier(specifier) {
+  if (!specifier) {
+    return false;
+  }
+  const normalized = stripQueryAndHash(specifier);
+  if (normalized.startsWith(VIRTUAL_PREFIX)) {
+    return false;
+  }
+  return !PROTOCOL_RE.test(normalized);
+}
+function toAbsoluteOutputPath(fileName, outDir) {
+  if (path.isAbsolute(fileName)) {
+    return fileName;
+  }
+  return path.resolve(outDir, fileName);
+}
+function matchWithExtensions(candidate, hasOutput) {
+  if (hasOutput(candidate)) {
+    return candidate;
+  }
+  if (!path.extname(candidate)) {
+    for (const ext of JS_EXTENSIONS) {
+      const extended = `${candidate}${ext}`;
+      if (hasOutput(extended)) {
+        return extended;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveOutputSpecifier(specifier, importer, outDir, hasOutput) {
+  if (!isResolvableSpecifier(specifier)) {
+    return void 0;
+  }
+  const normalized = stripQueryAndHash(specifier);
+  let candidate;
+  if (path.isAbsolute(normalized)) {
+    candidate = normalized;
+  } else if (normalized.startsWith("/")) {
+    candidate = path.resolve(outDir, normalized.slice(1));
+  } else {
+    candidate = path.resolve(path.dirname(importer), normalized);
+  }
+  return matchWithExtensions(candidate, hasOutput);
+}
+
+export {
+  toAbsoluteOutputPath,
+  resolveOutputSpecifier
+};

package/dist/{chunk-D25XJJMP.mjs → chunk-3KKB4FSY.mjs}

@@ -10,17 +10,14 @@ import {
 } from "./chunk-ZNKIYZRQ.mjs";
 
 // src/context/index.ts
-import { logger as logger2, pc } from "@weapp-tailwindcss/logger";
+import { logger as logger3, pc } from "@weapp-tailwindcss/logger";
 import { useMangleStore } from "@weapp-tailwindcss/mangle";
 
 // src/cache/index.ts
 import { LRUCache } from "lru-cache";
 
 // src/cache/md5.ts
-import crypto from "crypto";
-function md5Hash(data) {
-  return crypto.createHash("md5").update(data).digest("hex");
-}
+import { md5 } from "@weapp-tailwindcss/shared/node";
 
 // src/cache/index.ts
 function isProcessResult(value) {
@@ -54,7 +51,7 @@ function createCache(options) {
       return instance.set(key, value);
     },
     computeHash(message) {
-      return md5Hash(message);
+      return md5(message);
     },
     calcHashValueChanged(key, hash) {
       const hit = hashMap.get(key);
@@ -395,6 +392,274 @@ var JsTokenUpdater = class {
   }
 };
 
+// src/js/ModuleGraph.ts
+var JsModuleGraph = class {
+  constructor(entry, graphOptions) {
+    this.modules = /* @__PURE__ */ new Map();
+    this.queue = [];
+    this.ignoredExportNames = /* @__PURE__ */ new Map();
+    this.resolve = graphOptions.resolve;
+    this.load = graphOptions.load;
+    this.filter = graphOptions.filter;
+    this.maxDepth = graphOptions.maxDepth ?? Number.POSITIVE_INFINITY;
+    const { moduleGraph: _moduleGraph, filename: _ignoredFilename, ...rest } = entry.handlerOptions;
+    this.baseOptions = {
+      ...rest,
+      filename: entry.filename
+    };
+    this.parserOptions = entry.handlerOptions.babelParserOptions;
+    this.rootFilename = entry.filename;
+    this.modules.set(entry.filename, {
+      filename: entry.filename,
+      source: entry.source,
+      analysis: entry.analysis
+    });
+    this.queue.push({ filename: entry.filename, depth: 0 });
+  }
+  build() {
+    this.collectDependencies();
+    const linked = {};
+    for (const [filename, state] of this.modules) {
+      if (filename === this.rootFilename) {
+        continue;
+      }
+      const childOptions = {
+        ...this.baseOptions,
+        filename
+      };
+      const ms = processUpdatedSource(state.source, childOptions, state.analysis);
+      const code = ms.toString();
+      if (code !== state.source) {
+        linked[filename] = { code };
+      }
+    }
+    return linked;
+  }
+  addIgnoredExport(filename, exportName) {
+    if (!exportName) {
+      return;
+    }
+    let pending = this.ignoredExportNames.get(filename);
+    if (!pending) {
+      pending = /* @__PURE__ */ new Set();
+      this.ignoredExportNames.set(filename, pending);
+    }
+    if (pending.has(exportName)) {
+      return;
+    }
+    pending.add(exportName);
+    const existing = this.modules.get(filename);
+    if (existing) {
+      this.applyIgnoredExportsToAnalysis(filename, existing.analysis);
+    }
+  }
+  registerIgnoredExportsFromTokens(resolved, tokens) {
+    for (const token of tokens) {
+      if (token.type === "ImportSpecifier") {
+        this.addIgnoredExport(resolved, token.imported);
+      } else if (token.type === "ImportDefaultSpecifier") {
+        this.addIgnoredExport(resolved, "default");
+      }
+    }
+  }
+  applyIgnoredExportsToAnalysis(filename, analysis) {
+    const pending = this.ignoredExportNames.get(filename);
+    if (!pending || pending.size === 0) {
+      return;
+    }
+    const names = new Set(pending);
+    pending.clear();
+    const propagate = [];
+    for (const exportPath of analysis.exportDeclarations) {
+      if (names.size === 0) {
+        break;
+      }
+      if (exportPath.isExportDefaultDeclaration()) {
+        if (names.has("default")) {
+          analysis.walker.walkExportDefaultDeclaration(exportPath);
+          names.delete("default");
+        }
+        continue;
+      }
+      if (exportPath.isExportNamedDeclaration()) {
+        const source = exportPath.node.source?.value;
+        if (typeof source === "string") {
+          for (const spec of exportPath.get("specifiers")) {
+            if (!spec.isExportSpecifier()) {
+              continue;
+            }
+            const exported = spec.get("exported");
+            let exportedName;
+            if (exported.isIdentifier()) {
+              exportedName = exported.node.name;
+            } else if (exported.isStringLiteral()) {
+              exportedName = exported.node.value;
+            }
+            if (!exportedName || !names.has(exportedName)) {
+              continue;
+            }
+            const local = spec.get("local");
+            if (local.isIdentifier()) {
+              propagate.push({
+                specifier: source,
+                exportName: local.node.name
+              });
+              names.delete(exportedName);
+            } else if (local.isStringLiteral()) {
+              propagate.push({
+                specifier: source,
+                exportName: local.node.value
+              });
+              names.delete(exportedName);
+            }
+          }
+          continue;
+        }
+        const declaration = exportPath.get("declaration");
+        if (declaration.isVariableDeclaration()) {
+          for (const decl of declaration.get("declarations")) {
+            const id = decl.get("id");
+            if (id.isIdentifier()) {
+              const exportName = id.node.name;
+              if (names.has(exportName)) {
+                analysis.walker.walkVariableDeclarator(decl);
+                names.delete(exportName);
+              }
+            }
+          }
+        }
+        for (const spec of exportPath.get("specifiers")) {
+          if (!spec.isExportSpecifier()) {
+            continue;
+          }
+          const exported = spec.get("exported");
+          let exportedName;
+          if (exported.isIdentifier()) {
+            exportedName = exported.node.name;
+          } else if (exported.isStringLiteral()) {
+            exportedName = exported.node.value;
+          }
+          if (!exportedName || !names.has(exportedName)) {
+            continue;
+          }
+          const local = spec.get("local");
+          analysis.walker.walkNode(local);
+          names.delete(exportedName);
+        }
+        continue;
+      }
+      if (exportPath.isExportAllDeclaration()) {
+        const source = exportPath.node.source?.value;
+        if (typeof source === "string") {
+          for (const exportName of names) {
+            propagate.push({
+              specifier: source,
+              exportName
+            });
+          }
+          names.clear();
+        }
+      }
+    }
+    for (const { specifier, exportName } of propagate) {
+      let resolved;
+      try {
+        resolved = this.resolve(specifier, filename);
+      } catch {
+        resolved = void 0;
+      }
+      if (!resolved) {
+        pending.add(exportName);
+        continue;
+      }
+      if (this.filter && !this.filter(resolved, specifier, filename)) {
+        pending.add(exportName);
+        continue;
+      }
+      this.addIgnoredExport(resolved, exportName);
+    }
+    for (const name of names) {
+      pending.add(name);
+    }
+  }
+  collectDependencies() {
+    while (this.queue.length > 0) {
+      const { filename, depth } = this.queue.shift();
+      if (depth >= this.maxDepth) {
+        continue;
+      }
+      const state = this.modules.get(filename);
+      if (!state) {
+        continue;
+      }
+      const dependencySpecifiers = /* @__PURE__ */ new Map();
+      for (const token of state.analysis.walker.imports) {
+        if (!dependencySpecifiers.has(token.source)) {
+          dependencySpecifiers.set(token.source, []);
+        }
+        dependencySpecifiers.get(token.source).push(token);
+      }
+      for (const exportPath of state.analysis.exportDeclarations) {
+        if (exportPath.isExportAllDeclaration() || exportPath.isExportNamedDeclaration()) {
+          const source = exportPath.node.source?.value;
+          if (typeof source === "string" && !dependencySpecifiers.has(source)) {
+            dependencySpecifiers.set(source, []);
+          }
+        }
+      }
+      for (const [specifier, tokens] of dependencySpecifiers) {
+        let resolved;
+        try {
+          resolved = this.resolve(specifier, filename);
+        } catch {
+          continue;
+        }
+        if (!resolved) {
+          continue;
+        }
+        if (this.filter && !this.filter(resolved, specifier, filename)) {
+          continue;
+        }
+        if (tokens.length > 0) {
+          this.registerIgnoredExportsFromTokens(resolved, tokens);
+        }
+        if (this.modules.has(resolved)) {
+          continue;
+        }
+        let source;
+        try {
+          source = this.load(resolved);
+        } catch {
+          continue;
+        }
+        if (typeof source !== "string") {
+          continue;
+        }
+        let analysis;
+        try {
+          const ast = babelParse(source, {
+            ...this.parserOptions,
+            sourceFilename: resolved
+          });
+          analysis = analyzeSource(ast, {
+            ...this.baseOptions,
+            filename: resolved
+          });
+          this.applyIgnoredExportsToAnalysis(resolved, analysis);
+        } catch {
+          continue;
+        }
+        this.modules.set(resolved, {
+          filename: resolved,
+          source,
+          analysis
+        });
+        this.queue.push({ filename: resolved, depth: depth + 1 });
+      }
+    }
+  }
+};
+
 // src/js/NodePathWalker.ts
 var NodePathWalker = class {
   constructor({ ignoreCallExpressionIdentifiers, callback } = {}) {
@@ -494,6 +759,7 @@ var NodePathWalker = class {
                 declaration: importDeclaration,
                 specifier: arg,
                 imported: imported.node.name,
+                local: arg.node.local.name,
                 source: importDeclaration.node.source.value,
                 type: "ImportSpecifier"
               }
@@ -504,6 +770,7 @@ var NodePathWalker = class {
             {
               declaration: importDeclaration,
               specifier: arg,
+              local: arg.node.local.name,
               source: importDeclaration.node.source.value,
               type: "ImportDefaultSpecifier"
             }
@@ -555,6 +822,8 @@ var NodePathWalker = class {
     const decl = path2.get("declaration");
     if (decl.isIdentifier()) {
       this.walkNode(decl);
+    } else {
+      this.walkNode(decl);
     }
   }
   walkExportAllDeclaration(path2) {
@@ -782,12 +1051,28 @@ function jsHandler(rawSource, options) {
   }
   const analysis = analyzeSource(ast, options);
   const ms = processUpdatedSource(rawSource, options, analysis);
-  return {
+  const result = {
     code: ms.toString(),
     get map() {
       return ms.generateMap();
     }
   };
+  if (options.moduleGraph && options.filename) {
+    const graph = new JsModuleGraph(
+      {
+        filename: options.filename,
+        source: rawSource,
+        analysis,
+        handlerOptions: options
+      },
+      options.moduleGraph
+    );
+    const linked = graph.build();
+    if (Object.keys(linked).length > 0) {
+      result.linked = linked;
+    }
+  }
+  return result;
 }
 
 // src/js/index.ts
@@ -1325,8 +1610,38 @@ import { getPackageInfoSync } from "local-pkg";
 // src/tailwindcss/patcher.ts
 import path from "path";
 import process from "process";
+import { logger as logger2 } from "@weapp-tailwindcss/logger";
 import { defuOverrideArray as defuOverrideArray2 } from "@weapp-tailwindcss/shared";
 import { TailwindcssPatcher } from "tailwindcss-patch";
+function createFallbackTailwindcssPatcher() {
+  const packageInfo = {
+    name: "tailwindcss",
+    version: void 0,
+    rootPath: "",
+    packageJsonPath: "",
+    packageJson: {}
+  };
+  return {
+    packageInfo,
+    majorVersion: 0,
+    patch() {
+    },
+    async getClassSet() {
+      return /* @__PURE__ */ new Set();
+    },
+    getClassSetV3() {
+      return /* @__PURE__ */ new Set();
+    },
+    async extract(_options) {
+      const classSet = /* @__PURE__ */ new Set();
+      return {
+        classList: [],
+        classSet
+      };
+    }
+  };
+}
+var hasLoggedMissingTailwind = false;
 function createTailwindcssPatcher(options) {
   const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
   const cache = {};
@@ -1339,7 +1654,7 @@ function createTailwindcssPatcher(options) {
       cache.dir = path.resolve(process.cwd(), cacheDir);
     }
   }
-  return new TailwindcssPatcher(defuOverrideArray2(
+  const resolvedOptions = defuOverrideArray2(
     tailwindcssPatcherOptions,
     {
       cache,
@@ -1357,7 +1672,19 @@ function createTailwindcssPatcher(options) {
         }
       }
     }
-  ));
+  );
+  try {
+    return new TailwindcssPatcher(resolvedOptions);
+  } catch (error) {
+    if (error instanceof Error && /tailwindcss not found/i.test(error.message)) {
+      if (!hasLoggedMissingTailwind) {
+        logger2.warn("Tailwind CSS \u672A\u5B89\u88C5\uFF0C\u5DF2\u8DF3\u8FC7 Tailwind \u76F8\u5173\u8865\u4E01\u3002\u82E5\u9700\u4F7F\u7528 Tailwind \u80FD\u529B\uFF0C\u8BF7\u5B89\u88C5 tailwindcss\u3002");
+        hasLoggedMissingTailwind = true;
+      }
+      return createFallbackTailwindcssPatcher();
+    }
+    throw error;
+  }
 }
 
 // src/context/tailwindcss.ts
@@ -1399,7 +1726,11 @@ function getCompilerContext(opts) {
   ctx.escapeMap = ctx.customReplaceDictionary;
   applyLoggerLevel(ctx.logLevel);
   const twPatcher = createTailwindcssPatcherFromContext(ctx);
-  logger2.success(`\u5F53\u524D\u4F7F\u7528 ${pc.cyanBright("Tailwind CSS")} \u7248\u672C\u4E3A: ${pc.underline(pc.bold(pc.green(twPatcher.packageInfo.version)))}`);
+  if (twPatcher.packageInfo?.version) {
+    logger3.success(`\u5F53\u524D\u4F7F\u7528 ${pc.cyanBright("Tailwind CSS")} \u7248\u672C\u4E3A: ${pc.underline(pc.bold(pc.green(twPatcher.packageInfo.version)))}`);
+  } else {
+    logger3.warn(`${pc.cyanBright("Tailwind CSS")} \u672A\u5B89\u88C5\uFF0C\u5DF2\u8DF3\u8FC7\u7248\u672C\u68C0\u6D4B\u4E0E\u8865\u4E01\u5E94\u7528\u3002`);
+  }
   const cssCalcOptions = ctx.cssCalc ?? twPatcher.majorVersion === 4;
   const customAttributesEntities = toCustomAttributesEntities(ctx.customAttributes);
   const { initMangle, mangleContext, setMangleRuntimeSet } = useMangleStore();

package/dist/{chunk-D2AKCBDU.mjs → chunk-6L7B4COX.mjs}

@@ -4,10 +4,13 @@ import {
 } from "./chunk-H4JTYYOI.mjs";
 import {
   getCompilerContext
-} from "./chunk-D25XJJMP.mjs";
+} from "./chunk-3KKB4FSY.mjs";
 
 // src/bundlers/gulp/index.ts
 import { Buffer } from "buffer";
+import fs from "fs";
+import path from "path";
+import process from "process";
 import stream from "stream";
 var debug = createDebug();
 var Transform = stream.Transform;
@@ -16,6 +19,64 @@ function createPlugins(options = {}) {
   const { templateHandler, styleHandler, jsHandler, setMangleRuntimeSet, cache, twPatcher } = opts;
   let runtimeSet = /* @__PURE__ */ new Set();
   twPatcher.patch();
+  const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"];
+  function resolveWithExtensions(base) {
+    for (const ext of MODULE_EXTENSIONS) {
+      const candidate = `${base}${ext}`;
+      try {
+        if (fs.statSync(candidate).isFile()) {
+          return candidate;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return void 0;
+  }
+  function resolveLocalModuleCandidate(base) {
+    try {
+      const stat = fs.statSync(base);
+      if (stat.isFile()) {
+        return base;
+      }
+      if (stat.isDirectory()) {
+        const resolvedIndex = resolveWithExtensions(path.join(base, "index"));
+        if (resolvedIndex) {
+          return resolvedIndex;
+        }
+      }
+    } catch {
+    }
+    if (!path.extname(base)) {
+      return resolveWithExtensions(base);
+    }
+    return void 0;
+  }
+  function createModuleGraphOptionsFor() {
+    return {
+      resolve(specifier, importer) {
+        if (!specifier) {
+          return void 0;
+        }
+        if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) {
+          return void 0;
+        }
+        const normalized = path.resolve(path.dirname(importer), specifier);
+        return resolveLocalModuleCandidate(normalized);
+      },
+      load(id) {
+        try {
+          return fs.readFileSync(id, "utf8");
+        } catch {
+          return void 0;
+        }
+      },
+      filter(id) {
+        const relative = path.relative(process.cwd(), id);
+        return opts.jsMatcher(relative) || opts.wxsMatcher(relative);
+      }
+    };
+  }
   function createVinylTransform(handler) {
     return new Transform({
       objectMode: true,
@@ -63,6 +124,17 @@ function createPlugins(options = {}) {
     if (!file.contents) {
       return;
     }
+    const filename = path.resolve(file.path);
+    const moduleGraph = options2.moduleGraph ?? createModuleGraphOptionsFor();
+    const handlerOptions = {
+      ...options2,
+      filename,
+      moduleGraph,
+      babelParserOptions: {
+        ...options2?.babelParserOptions ?? {},
+        sourceFilename: filename
+      }
+    };
     const rawSource = file.contents.toString();
     await processCachedTask({
       cache,
@@ -75,7 +147,8 @@ function createPlugins(options = {}) {
         debug("js cache hit: %s", file.path);
       },
       async transform() {
-        const { code } = await jsHandler(rawSource, runtimeSet, options2);
+        const currentSource = file.contents?.toString() ?? rawSource;
+        const { code } = await jsHandler(currentSource, runtimeSet, handlerOptions);
         debug("js handle: %s", file.path);
         return {
           result: code