weapp-tailwindcss 5.0.0-next.1 → 5.0.0-next.11

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/bundle-state-BRkhpjio.js

@@ -0,0 +1,448 @@
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_precheck = require("./precheck-D5eEdqeH.js");
+let node_module = require("node:module");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_buffer = require("node:buffer");
+let htmlparser2 = require("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 node_path.default.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 (node_path.default.isAbsolute(normalized) || WINDOWS_ABSOLUTE_RE.test(normalized)) return true;
+	return !PROTOCOL_RE.test(normalized);
+}
+function toAbsoluteOutputPath(fileName, outDir) {
+	if (node_path.default.isAbsolute(fileName) || WINDOWS_ABSOLUTE_RE.test(fileName)) return node_path.default.normalize(fileName);
+	return node_path.default.resolve(outDir, fileName);
+}
+function matchWithExtensions(candidate, hasOutput) {
+	if (hasOutput(candidate)) return candidate;
+	if (!node_path.default.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 (node_path.default.isAbsolute(normalized) || WINDOWS_ABSOLUTE_RE.test(normalized)) candidate = node_path.default.normalize(normalized);
+	else if (normalized.startsWith("/")) candidate = node_path.default.resolve(outDir, normalized.slice(1));
+	else candidate = node_path.default.resolve(node_path.default.dirname(importer), normalized);
+	return matchWithExtensions(candidate, hasOutput);
+}
+//#endregion
+//#region src/bundlers/shared/style-requests.ts
+const SOURCE_STYLE_EXT_RE = /\.(?:css|scss|sass|less|styl|stylus|pcss|postcss)$/i;
+const STYLE_QUERY_RE = /(?:^|&)type=styles?(?:&|$)/;
+const STYLE_LANG_QUERY_RE = /(?:^|&)lang(?:[.=](?:css|scss|sass|less|styl|stylus|pcss|postcss))?(?:&|$)/;
+function stripHash(request) {
+	const hashIndex = request.indexOf("#");
+	return hashIndex === -1 ? request : request.slice(0, hashIndex);
+}
+function stripRequestQuery(request) {
+	const normalized = stripHash(request);
+	const queryIndex = normalized.indexOf("?");
+	return queryIndex === -1 ? normalized : normalized.slice(0, queryIndex);
+}
+function isSourceStyleRequest(request) {
+	if (typeof request !== "string" || request.length === 0) return false;
+	const normalized = stripHash(request);
+	const queryIndex = normalized.indexOf("?");
+	const pathname = queryIndex === -1 ? normalized : normalized.slice(0, queryIndex);
+	if (SOURCE_STYLE_EXT_RE.test(pathname)) return true;
+	if (queryIndex === -1) return false;
+	const query = normalized.slice(queryIndex + 1);
+	return STYLE_QUERY_RE.test(query) || STYLE_LANG_QUERY_RE.test(query);
+}
+//#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$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+function resolvePackageDir(name) {
+	const pkgPath = require$1.resolve(`${name}/package.json`);
+	return node_path.default.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 factory = factories[currentIndex];
+		if (!factory) return;
+		const wrapped = Promise.resolve(factory()).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 node_buffer.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 htmlparser2.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 = require_precheck.babelParse(source, {
+			cache: true,
+			cacheKey: "vite-runtime-affecting:unambiguous",
+			plugins: ["jsx", "typescript"],
+			sourceType: "unambiguous"
+		});
+		const parts = [];
+		require_precheck.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
+Object.defineProperty(exports, "applyLinkedResults", {
+	enumerable: true,
+	get: function() {
+		return applyLinkedResults;
+	}
+});
+Object.defineProperty(exports, "buildBundleSnapshot", {
+	enumerable: true,
+	get: function() {
+		return buildBundleSnapshot;
+	}
+});
+Object.defineProperty(exports, "createBundleBuildState", {
+	enumerable: true,
+	get: function() {
+		return createBundleBuildState;
+	}
+});
+Object.defineProperty(exports, "createBundleModuleGraphOptions", {
+	enumerable: true,
+	get: function() {
+		return createBundleModuleGraphOptions;
+	}
+});
+Object.defineProperty(exports, "isSourceStyleRequest", {
+	enumerable: true,
+	get: function() {
+		return isSourceStyleRequest;
+	}
+});
+Object.defineProperty(exports, "normalizeOutputPathKey", {
+	enumerable: true,
+	get: function() {
+		return normalizeOutputPathKey;
+	}
+});
+Object.defineProperty(exports, "pushConcurrentTaskFactories", {
+	enumerable: true,
+	get: function() {
+		return pushConcurrentTaskFactories;
+	}
+});
+Object.defineProperty(exports, "resolveOutputSpecifier", {
+	enumerable: true,
+	get: function() {
+		return resolveOutputSpecifier;
+	}
+});
+Object.defineProperty(exports, "resolvePackageDir", {
+	enumerable: true,
+	get: function() {
+		return resolvePackageDir;
+	}
+});
+Object.defineProperty(exports, "resolvePluginDisabledState", {
+	enumerable: true,
+	get: function() {
+		return resolvePluginDisabledState;
+	}
+});
+Object.defineProperty(exports, "stripRequestQuery", {
+	enumerable: true,
+	get: function() {
+		return stripRequestQuery;
+	}
+});
+Object.defineProperty(exports, "toAbsoluteOutputPath", {
+	enumerable: true,
+	get: function() {
+		return toAbsoluteOutputPath;
+	}
+});
+Object.defineProperty(exports, "updateBundleBuildState", {
+	enumerable: true,
+	get: function() {
+		return updateBundleBuildState;
+	}
+});