weapp-tailwindcss 4.12.0 → 5.0.0-next.10

package/README.md

@@ -15,7 +15,6 @@
 
 ![star](https://badgen.net/github/stars/sonofmagic/weapp-tailwindcss)
 ![dm0](https://badgen.net/npm/dm/weapp-tailwindcss)
-![dm1](https://badgen.net/npm/dm/weapp-tailwindcss-webpack-plugin)
 ![license](https://badgen.net/npm/license/weapp-tailwindcss)
 [![test](https://github.com/sonofmagic/weapp-tailwindcss/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/sonofmagic/weapp-tailwindcss/actions/workflows/test.yml)
 [![codecov](https://codecov.io/gh/sonofmagic/weapp-tailwindcss/branch/main/graph/badge.svg?token=zn05qXYznt)](https://codecov.io/gh/sonofmagic/weapp-tailwindcss)
@@ -55,12 +54,12 @@
 
 ## 版本对应
 
-目前，`weapp-tailwindcss` 的 `4.x` 版本
+目前，`weapp-tailwindcss` 的 `5.x` 版本
 
-- 支持最新版本的 `tailwindcss v4` 和 `v3` 还有 `v2 jit` 版本。
-- 支持 `webpack5`，`webpack4`, `vite` 和 `gulp` 这些打包工具，也支持纯 `Nodejs` API 的方式，集成到你自己的构建工具中。
+- 支持最新版本的 `tailwindcss v4` 和 `v3`。
+- 支持 `webpack5`、`vite`、`rspack`、`rollup`、`rolldown` 和 `gulp` 这些打包工具，也支持纯 `Nodejs` API 的方式，集成到你自己的构建工具中。
 
-> 如果你还在使用 `tailwindcss@2` 版本，那你应该使用从 `weapp-tailwindcss/webpack4` 导出的本插件的 `postcss7` `webpack4` 版本。另外请确保你的 `nodejs` 版本 `>=16.6.0`。目前低于 `16` 的长期维护版本(`偶数版本`) 都已经结束了生命周期，建议安装 `nodejs` 的 `LTS` 版本，详见 [nodejs/release](https://github.com/nodejs/release)
+> `weapp-tailwindcss@5` 面向 Tailwind CSS v3/v4 和现代构建链路，不再内置 Webpack4、PostCSS7、Tailwind CSS v2 兼容入口。`weapp-tailwindcss@5` 需要 `nodejs` 版本 `^20.19.0 || >=22.12.0`，建议安装 `nodejs` 的 `LTS` 版本，详见 [nodejs/release](https://github.com/nodejs/release)
 
 ## [安装与使用方式](https://tw.icebreaker.top/docs/quick-start/install)
 

package/bin/weapp-tailwindcss.js

@@ -1,28 +1,8 @@
 #!/usr/bin/env node
 const fs = require('node:fs')
 const path = require('node:path')
-const process = require('node:process')
-
-function isInstallLifecycle() {
-  return process.env.npm_lifecycle_event === 'postinstall' || process.env.npm_lifecycle_event === 'prepare'
-}
-
-function isMissingRuntimeModuleError(error) {
-  return error && error.code === 'MODULE_NOT_FOUND'
-}
 
 const cliPath = path.resolve(__dirname, '../dist/cli.js')
 if (fs.existsSync(cliPath)) {
-  try {
-    require(cliPath)
-  }
-  catch (error) {
-    if (isInstallLifecycle() && isMissingRuntimeModuleError(error)) {
-      console.error('[weapp-tailwindcss] install lifecycle patch skipped because a runtime module is missing.')
-      console.error('Run `pnpm --filter weapp-tailwindcss build` before strict CLI validation.')
-    }
-    else {
-      throw error
-    }
-  }
+  require(cliPath)
 }

package/dist/babel/index.d.ts

@@ -0,0 +1,3 @@
+import _babelTraverse from '@babel/traverse';
+export { parse, parseExpression } from '@babel/parser';
+export declare const traverse: typeof _babelTraverse;

package/dist/bundle-state-BWqi5ZyX.mjs

@@ -0,0 +1,343 @@
+import { d as traverse, u as babelParse } from "./precheck-B4RH6ZNN.mjs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+import { Parser } from "htmlparser2";
+//#region src/bundlers/shared/module-graph.ts
+const QUERY_HASH_RE = /[?#].*$/u;
+const PROTOCOL_RE = /^[a-z][a-z+.-]*:/iu;
+const WINDOWS_ABSOLUTE_RE = /^[a-z]:[\\/]/iu;
+const VIRTUAL_PREFIX = "\0";
+const JS_EXTENSIONS = [
+	".js",
+	".mjs",
+	".cjs"
+];
+function normalizeOutputPathKey(value) {
+	return path.normalize(value).replace(/\\/g, "/");
+}
+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;
+	if (path.isAbsolute(normalized) || WINDOWS_ABSOLUTE_RE.test(normalized)) return true;
+	return !PROTOCOL_RE.test(normalized);
+}
+function toAbsoluteOutputPath(fileName, outDir) {
+	if (path.isAbsolute(fileName) || WINDOWS_ABSOLUTE_RE.test(fileName)) return path.normalize(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;
+	}
+}
+function resolveOutputSpecifier(specifier, importer, outDir, hasOutput) {
+	if (!isResolvableSpecifier(specifier)) return;
+	const normalized = stripQueryAndHash(specifier);
+	let candidate;
+	if (path.isAbsolute(normalized) || WINDOWS_ABSOLUTE_RE.test(normalized)) candidate = path.normalize(normalized);
+	else if (normalized.startsWith("/")) candidate = path.resolve(outDir, normalized.slice(1));
+	else candidate = path.resolve(path.dirname(importer), normalized);
+	return matchWithExtensions(candidate, hasOutput);
+}
+//#endregion
+//#region src/utils/disabled.ts
+function resolvePluginDisabledState(disabled) {
+	if (disabled === true) return { plugin: true };
+	if (disabled === false || disabled == null) return { plugin: false };
+	return { plugin: disabled.plugin ?? false };
+}
+//#endregion
+//#region src/utils/resolve-package.ts
+const require = createRequire(import.meta.url);
+function resolvePackageDir(name) {
+	const pkgPath = require.resolve(`${name}/package.json`);
+	return path.dirname(pkgPath);
+}
+//#endregion
+//#region src/bundlers/shared/run-tasks.ts
+async function runWithConcurrency(factories, limit = Math.min(4, Math.max(1, factories.length))) {
+	if (factories.length === 0) return [];
+	const results = Array.from({ length: factories.length });
+	const executing = /* @__PURE__ */ new Set();
+	let cursor = 0;
+	const effectiveLimit = Math.max(1, limit);
+	const scheduleNext = () => {
+		if (cursor >= factories.length) return;
+		const currentIndex = cursor++;
+		const wrapped = Promise.resolve(factories[currentIndex]()).then((value) => {
+			results[currentIndex] = value;
+		}).finally(() => {
+			executing.delete(wrapped);
+		});
+		executing.add(wrapped);
+	};
+	while (cursor < factories.length && executing.size < effectiveLimit) scheduleNext();
+	while (cursor < factories.length) {
+		await Promise.race(executing);
+		scheduleNext();
+	}
+	await Promise.all(executing);
+	return results;
+}
+function pushConcurrentTaskFactories(queue, factories, limit) {
+	if (factories.length === 0) return;
+	queue.push(runWithConcurrency(factories, limit).then(() => void 0));
+}
+//#endregion
+//#region src/bundlers/vite/bundle-entries.ts
+function readOutputEntry(entry) {
+	if (entry.output.type === "chunk") return entry.output.code;
+	const source = entry.output.source;
+	if (typeof source === "string") return source;
+	if (source instanceof Uint8Array) return Buffer.from(source).toString();
+	const fallbackSource = source;
+	if (fallbackSource == null) return;
+	if (typeof fallbackSource.toString === "function") return fallbackSource.toString();
+}
+function isJavaScriptEntry(entry) {
+	if (entry.output.type === "chunk") return true;
+	return entry.fileName.endsWith(".js");
+}
+function createBundleModuleGraphOptions(outputDir, entries) {
+	const normalizedEntries = /* @__PURE__ */ new Map();
+	for (const [id, entry] of entries) normalizedEntries.set(normalizeOutputPathKey(id), entry);
+	const getEntry = (id) => entries.get(id) ?? normalizedEntries.get(normalizeOutputPathKey(id));
+	return {
+		resolve(specifier, importer) {
+			return resolveOutputSpecifier(specifier, importer, outputDir, (candidate) => Boolean(getEntry(candidate)));
+		},
+		load(id) {
+			const entry = getEntry(id);
+			if (!entry) return;
+			return readOutputEntry(entry);
+		},
+		filter(id) {
+			return Boolean(getEntry(id));
+		}
+	};
+}
+function applyLinkedResults(linked, entries, onLinkedUpdate, onApplied) {
+	if (!linked) return;
+	const normalizedEntries = /* @__PURE__ */ new Map();
+	for (const [entryId, entry] of entries) normalizedEntries.set(normalizeOutputPathKey(entryId), entry);
+	for (const [id, { code }] of Object.entries(linked)) {
+		const entry = entries.get(id) ?? normalizedEntries.get(normalizeOutputPathKey(id));
+		if (!entry) continue;
+		const previous = readOutputEntry(entry);
+		if (previous == null || previous === code) continue;
+		if (entry.output.type === "chunk") entry.output.code = code;
+		else entry.output.source = code;
+		onApplied?.(entry, code);
+		onLinkedUpdate(entry.fileName, previous, code);
+	}
+}
+//#endregion
+//#region src/bundlers/vite/runtime-affecting-signature.ts
+const CSS_BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+const CSS_AROUND_PUNCTUATION_RE = /\s*([{}:;,>+~()])\s*/g;
+const CSS_TRAILING_DECLARATION_SEMICOLON_RE = /;\}/g;
+const CSS_WHITESPACE_RE = /\s+/g;
+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;
+	}
+}
+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(path) {
+				parts.push(`s:${path.node.value}`);
+			},
+			TemplateElement(path) {
+				parts.push(`t:${path.node.value.raw}`);
+			},
+			JSXText(path) {
+				const value = path.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;
+	}
+}
+function createCssRuntimeAffectingSignature(source) {
+	return source.replace(CSS_BLOCK_COMMENT_RE, "").replace(CSS_AROUND_PUNCTUATION_RE, "$1").replace(CSS_TRAILING_DECLARATION_SEMICOLON_RE, "}").replace(CSS_WHITESPACE_RE, " ").trim();
+}
+function createRuntimeAffectingSourceSignature(source, type) {
+	if (type === "html") return createHtmlRuntimeAffectingSignature(source);
+	if (type === "js") return createJsRuntimeAffectingSignature(source);
+	if (type === "css") return createCssRuntimeAffectingSignature(source);
+	return source;
+}
+//#endregion
+//#region src/bundlers/vite/bundle-state.ts
+function createBundleBuildState() {
+	return {
+		iteration: 0,
+		sourceHashByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+		linkedByEntry: /* @__PURE__ */ new Map(),
+		dependentsByLinkedFile: /* @__PURE__ */ new Map()
+	};
+}
+function createChangedByType() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set(),
+		other: /* @__PURE__ */ new Set()
+	};
+}
+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";
+	if (opts.htmlMatcher(file)) return "html";
+	if (opts.jsMatcher(file) || opts.wxsMatcher(file)) return "js";
+	return "other";
+}
+function collectJsEntries(fileName, output, outDir, store) {
+	const entry = {
+		fileName,
+		output
+	};
+	if (!isJavaScriptEntry(entry)) return;
+	const absolute = toAbsoluteOutputPath(fileName, outDir);
+	store.set(absolute, entry);
+}
+function markProcessFile(type, file, processFiles) {
+	if (type === "html" || type === "js" || type === "css") processFiles[type].add(file);
+}
+function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false) {
+	const sourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeAffectingSignatureByFile = /* @__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);
+		sourceHashByFile.set(file, hash);
+		const previousHash = state.sourceHashByFile.get(file);
+		const changed = previousHash == null || previousHash !== hash;
+		const previousRuntimeAffectingSignature = state.runtimeAffectingSignatureByFile.get(file);
+		const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
+		const canReuseRuntimeAffectingSignature = !changed && previousRuntimeAffectingSignature != null && previousRuntimeAffectingHash != null;
+		const runtimeAffectingSignature = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingSignature : createRuntimeAffectingSourceSignature(source, type);
+		const runtimeAffectingHash = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingHash : opts.cache.computeHash(runtimeAffectingSignature);
+		runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
+		runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
+		if (changed) changedByType[type].add(file);
+		if (previousRuntimeAffectingHash == null || previousRuntimeAffectingHash !== runtimeAffectingHash) runtimeAffectingChangedByType[type].add(file);
+		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
+		});
+	}
+	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) {
+				impacts = /* @__PURE__ */ new Set();
+				linkedImpactsByEntry.set(entryFile, impacts);
+			}
+			impacts.add(changedFile);
+		}
+	}
+	return {
+		entries,
+		jsEntries,
+		sourceHashByFile,
+		runtimeAffectingSignatureByFile,
+		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, options = {}) {
+	const incremental = options.incremental === true;
+	state.iteration += 1;
+	state.sourceHashByFile = incremental ? new Map([...state.sourceHashByFile, ...snapshot.sourceHashByFile]) : snapshot.sourceHashByFile;
+	state.runtimeAffectingSignatureByFile = incremental ? new Map([...state.runtimeAffectingSignatureByFile, ...snapshot.runtimeAffectingSignatureByFile]) : snapshot.runtimeAffectingSignatureByFile;
+	state.runtimeAffectingHashByFile = incremental ? new Map([...state.runtimeAffectingHashByFile, ...snapshot.runtimeAffectingHashByFile]) : snapshot.runtimeAffectingHashByFile;
+	state.linkedByEntry = incremental ? new Map([...state.linkedByEntry, ...linkedByEntry]) : linkedByEntry;
+	state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
+}
+//#endregion
+export { createBundleModuleGraphOptions as a, resolvePluginDisabledState as c, toAbsoluteOutputPath as d, applyLinkedResults as i, normalizeOutputPathKey as l, createBundleBuildState as n, pushConcurrentTaskFactories as o, updateBundleBuildState as r, resolvePackageDir as s, buildBundleSnapshot as t, resolveOutputSpecifier as u };