weapp-tailwindcss 5.0.0-next.3 → 5.0.0-next.30

package/dist/generator-Qw-tZ0Z2.mjs

@@ -0,0 +1,65 @@
+import { C as createTailwindV4Engine, i as createTailwindV3Engine, n as resolveTailwindV3SourceFromPatcher, x as resolveTailwindV4SourceFromPatcher } from "./v3-engine-DcvCCHfs.mjs";
+import process from "node:process";
+//#region src/generator/options.ts
+const explicitGeneratorTargetEnvKeys = ["WEAPP_TW_TARGET", "WEAPP_TAILWINDCSS_TARGET"];
+const uniWebPlatformEnvKeys = ["UNI_PLATFORM", "UNI_UTS_PLATFORM"];
+const mpxWebPlatformEnvKeys = ["MPX_CLI_MODE", "MPX_CURRENT_TARGET_MODE"];
+function getEnvValue(key) {
+	return typeof process === "undefined" ? void 0 : process.env[key];
+}
+function normalizeGeneratorTargetValue(value) {
+	return value === "weapp" || value === "web" || value === "tailwind" ? value : void 0;
+}
+function isUniWebPlatform(value) {
+	const normalized = value?.trim().toLowerCase();
+	return normalized === "h5" || normalized?.startsWith("web") === true;
+}
+function isUniAppWebViewPlatform(value) {
+	const normalized = value?.trim().toLowerCase();
+	return normalized === "app" || normalized === "app-plus";
+}
+function isUniNativeAppPlatform(value) {
+	return (value?.trim().toLowerCase())?.startsWith("app-") === true;
+}
+function isMpxWebPlatform(value) {
+	return value?.trim().toLowerCase() === "web";
+}
+function inferGeneratorTargetFromEnv() {
+	for (const key of explicitGeneratorTargetEnvKeys) {
+		const target = normalizeGeneratorTargetValue(getEnvValue(key));
+		if (target !== void 0) return target;
+	}
+	if (uniWebPlatformEnvKeys.some((key) => isUniWebPlatform(getEnvValue(key))) || isUniAppWebViewPlatform(getEnvValue("UNI_PLATFORM")) && !isUniNativeAppPlatform(getEnvValue("UNI_UTS_PLATFORM")) || mpxWebPlatformEnvKeys.some((key) => isMpxWebPlatform(getEnvValue(key))) || getEnvValue("TARO_ENV") === "h5") return "web";
+	return "weapp";
+}
+function normalizeWeappTailwindcssGeneratorOptions(options) {
+	const target = options?.target ?? inferGeneratorTargetFromEnv();
+	if (options == null) return {
+		target,
+		importFallback: true,
+		tailwindcssV3Compatibility: target === "weapp"
+	};
+	return {
+		target,
+		config: options.config,
+		styleOptions: options.styleOptions,
+		importFallback: options.importFallback ?? true,
+		tailwindcssV3Compatibility: options.tailwindcssV3Compatibility ?? target === "weapp"
+	};
+}
+//#endregion
+//#region src/generator/index.ts
+function isTailwindV3Source(source) {
+	return "version" in source && source.version === 3;
+}
+function createWeappTailwindcssGenerator(source) {
+	return isTailwindV3Source(source) ? createTailwindV3Engine(source) : createTailwindV4Engine(source);
+}
+async function resolveTailwindSourceFromPatcher(patcher) {
+	return patcher.majorVersion === 3 ? resolveTailwindV3SourceFromPatcher(patcher) : resolveTailwindV4SourceFromPatcher(patcher);
+}
+async function createWeappTailwindcssGeneratorFromPatcher(patcher) {
+	return createWeappTailwindcssGenerator(await resolveTailwindSourceFromPatcher(patcher));
+}
+//#endregion
+export { normalizeWeappTailwindcssGeneratorOptions as i, createWeappTailwindcssGeneratorFromPatcher as n, resolveTailwindSourceFromPatcher as r, createWeappTailwindcssGenerator as t };

package/dist/generator.js

@@ -1,19 +1,19 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./chunk-8l464Juk.js");
-const require_generator = require("./generator-mmhXzZnv.js");
+const require_v3_engine = require("./v3-engine-CHItlVq5.js");
+const require_generator = require("./generator-CrU-Ghc1.js");
 let tailwindcss_patch = require("tailwindcss-patch");
 exports.createWeappTailwindcssGenerator = require_generator.createWeappTailwindcssGenerator;
 exports.createWeappTailwindcssGeneratorFromPatcher = require_generator.createWeappTailwindcssGeneratorFromPatcher;
 exports.normalizeWeappTailwindcssGeneratorOptions = require_generator.normalizeWeappTailwindcssGeneratorOptions;
 exports.resolveTailwindSourceFromPatcher = require_generator.resolveTailwindSourceFromPatcher;
-exports.resolveTailwindV3Source = require_generator.resolveTailwindV3Source;
-exports.resolveTailwindV3SourceFromPatcher = require_generator.resolveTailwindV3SourceFromPatcher;
-exports.resolveTailwindV3SourceOptionsFromPatcher = require_generator.resolveTailwindV3SourceOptionsFromPatcher;
-exports.resolveTailwindV4Source = require_generator.resolveTailwindV4Source;
+exports.resolveTailwindV3Source = require_v3_engine.resolveTailwindV3Source;
+exports.resolveTailwindV3SourceFromPatcher = require_v3_engine.resolveTailwindV3SourceFromPatcher;
+exports.resolveTailwindV3SourceOptionsFromPatcher = require_v3_engine.resolveTailwindV3SourceOptionsFromPatcher;
+exports.resolveTailwindV4Source = require_v3_engine.resolveTailwindV4Source;
 exports.resolveTailwindV4SourceFromPatchOptions = tailwindcss_patch.resolveTailwindV4SourceFromPatchOptions;
-exports.resolveTailwindV4SourceFromPatcher = require_generator.resolveTailwindV4SourceFromPatcher;
-exports.resolveTailwindV4SourceOptionsFromPatcher = require_generator.resolveTailwindV4SourceOptionsFromPatcher;
-exports.transformTailwindV3CssByTarget = require_generator.transformTailwindV3CssByTarget;
-exports.transformTailwindV3CssToWeapp = require_generator.transformTailwindV3CssToWeapp;
-exports.transformTailwindV4CssByTarget = require_generator.transformTailwindV4CssByTarget;
-exports.transformTailwindV4CssToWeapp = require_generator.transformTailwindV4CssToWeapp;
+exports.resolveTailwindV4SourceFromPatcher = require_v3_engine.resolveTailwindV4SourceFromPatcher;
+exports.resolveTailwindV4SourceOptionsFromPatcher = require_v3_engine.resolveTailwindV4SourceOptionsFromPatcher;
+exports.transformTailwindV3CssByTarget = require_v3_engine.transformTailwindV3CssByTarget;
+exports.transformTailwindV3CssToWeapp = require_v3_engine.transformTailwindV3CssToWeapp;
+exports.transformTailwindV4CssByTarget = require_v3_engine.transformTailwindV4CssByTarget;
+exports.transformTailwindV4CssToWeapp = require_v3_engine.transformTailwindV4CssToWeapp;

package/dist/generator.mjs

@@ -1,2 +1,3 @@
-import { _ as transformTailwindV3CssToWeapp, a as resolveTailwindV4Source, c as resolveTailwindV4SourceOptionsFromPatcher, g as transformTailwindV3CssByTarget, h as resolveTailwindV3SourceOptionsFromPatcher, i as normalizeWeappTailwindcssGeneratorOptions, l as transformTailwindV4CssByTarget, m as resolveTailwindV3SourceFromPatcher, n as createWeappTailwindcssGeneratorFromPatcher, o as resolveTailwindV4SourceFromPatchOptions, p as resolveTailwindV3Source, r as resolveTailwindSourceFromPatcher, s as resolveTailwindV4SourceFromPatcher, t as createWeappTailwindcssGenerator, u as transformTailwindV4CssToWeapp } from "./generator-Y-Ikv4Fu.mjs";
+import { S as resolveTailwindV4SourceOptionsFromPatcher, T as transformTailwindV4CssToWeapp, a as transformTailwindV3CssByTarget, b as resolveTailwindV4SourceFromPatchOptions, n as resolveTailwindV3SourceFromPatcher, o as transformTailwindV3CssToWeapp, r as resolveTailwindV3SourceOptionsFromPatcher, t as resolveTailwindV3Source, w as transformTailwindV4CssByTarget, x as resolveTailwindV4SourceFromPatcher, y as resolveTailwindV4Source } from "./v3-engine-DcvCCHfs.mjs";
+import { i as normalizeWeappTailwindcssGeneratorOptions, n as createWeappTailwindcssGeneratorFromPatcher, r as resolveTailwindSourceFromPatcher, t as createWeappTailwindcssGenerator } from "./generator-Qw-tZ0Z2.mjs";
 export { createWeappTailwindcssGenerator, createWeappTailwindcssGeneratorFromPatcher, normalizeWeappTailwindcssGeneratorOptions, resolveTailwindSourceFromPatcher, resolveTailwindV3Source, resolveTailwindV3SourceFromPatcher, resolveTailwindV3SourceOptionsFromPatcher, resolveTailwindV4Source, resolveTailwindV4SourceFromPatchOptions, resolveTailwindV4SourceFromPatcher, resolveTailwindV4SourceOptionsFromPatcher, transformTailwindV3CssByTarget, transformTailwindV3CssToWeapp, transformTailwindV4CssByTarget, transformTailwindV4CssToWeapp };

package/dist/gulp.js

@@ -1,18 +1,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_chunk = require("./chunk-8l464Juk.js");
-const require_recorder = require("./recorder-GdTJ3QqX.js");
-const require_generator_css = require("./generator-css-CRLrHW4F.js");
+const require_chunk = require("./chunk-C5U5_Hdc.js");
+const require_v3_engine = require("./v3-engine-CHItlVq5.js");
+const require_incremental_runtime_class_set = require("./incremental-runtime-class-set-BxvZONkv.js");
+const require_precheck = require("./precheck-D7gJSmJz.js");
+const require_tailwindcss = require("./tailwindcss-B-e2RiXr.js");
+const require_source_candidates = require("./source-candidates-DNM8iwXW.js");
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
 let node_buffer = require("node:buffer");
-let node_fs = require("node:fs");
-node_fs = require_chunk.__toESM(node_fs);
 let node_stream = require("node:stream");
 node_stream = require_chunk.__toESM(node_stream);
 //#region src/bundlers/gulp/index.ts
-const debug = require_recorder.createDebug();
+const debug = require_v3_engine.createDebug();
 const Transform = node_stream.default.Transform;
 /**
 * @name weapp-tw-gulp
@@ -20,18 +23,18 @@ const Transform = node_stream.default.Transform;
 * @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
 */
 function createPlugins(options = {}) {
-	const opts = require_recorder.getCompilerContext(options);
-	const { templateHandler, styleHandler, jsHandler, cache, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = opts;
-	const patchRecorderState = require_recorder.setupPatchRecorder(initialTwPatcher, opts.tailwindcssBasedir, {
-		source: "runtime",
-		cwd: opts.tailwindcssBasedir ?? node_process.default.cwd()
+	const hasInitialTailwindCssRoots = require_tailwindcss.hasConfiguredTailwindV4CssRoots(options);
+	const opts = require_precheck.getCompilerContext({
+		...options,
+		__internalDeferMissingCssEntriesWarning: true
 	});
+	const { templateHandler, styleHandler, jsHandler, cache, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = opts;
+	const readyPromise = require_precheck.createTailwindRuntimeReadyPromise(initialTwPatcher);
 	let runtimeSet = /* @__PURE__ */ new Set();
 	const runtimeState = {
 		twPatcher: initialTwPatcher,
-		patchPromise: patchRecorderState.patchPromise,
-		refreshTailwindcssPatcher,
-		onPatchCompleted: patchRecorderState.onPatchCompleted
+		readyPromise,
+		refreshTailwindcssPatcher
 	};
 	const defaultStyleHandlerOptionsCache = /* @__PURE__ */ new Map();
 	let cachedDefaultTemplateHandlerOptions;
@@ -46,20 +49,138 @@ function createPlugins(options = {}) {
 		".jsx"
 	];
 	let runtimeSetInitialized = false;
-	async function refreshRuntimeState(force) {
-		await require_recorder.refreshTailwindRuntimeState(runtimeState, force);
-	}
-	async function refreshRuntimeSet(force = false) {
-		if (!force && runtimeSetInitialized) return runtimeSet;
-		runtimeSet = await require_recorder.ensureRuntimeClassSet(runtimeState, {
-			forceRefresh: force,
-			forceCollect: force,
-			clearCache: force,
+	let runtimeSetDirty = false;
+	const runtimeSourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeSourcesByFile = /* @__PURE__ */ new Map();
+	let cachedGulpSourceCandidates;
+	let cachedGulpSourceCandidateSignature;
+	const bundleRuntimeClassSetManager = options.__internalGulpRuntimeClassSetManager ?? require_incremental_runtime_class_set.createBundleRuntimeClassSetManager();
+	async function refreshRuntimeSet(options = false) {
+		const normalizedOptions = typeof options === "boolean" ? {
+			forceRefresh: options,
+			forceCollect: options,
+			clearCache: options
+		} : options;
+		const forceRefresh = normalizedOptions.forceRefresh === true;
+		const shouldForceCollect = normalizedOptions.forceCollect === true || runtimeSetDirty;
+		const clearCache = normalizedOptions.clearCache === true || runtimeSetDirty;
+		if (!forceRefresh && !shouldForceCollect && runtimeSetInitialized) return runtimeSet;
+		runtimeSet = await require_precheck.ensureRuntimeClassSet(runtimeState, {
+			forceRefresh,
+			forceCollect: shouldForceCollect,
+			clearCache,
 			allowEmpty: false
 		});
 		runtimeSetInitialized = true;
+		runtimeSetDirty = false;
 		return runtimeSet;
 	}
+	function createRuntimeSnapshot(changedFiles) {
+		const runtimeAffectingChangedByType = {
+			html: /* @__PURE__ */ new Set(),
+			js: /* @__PURE__ */ new Set(),
+			css: /* @__PURE__ */ new Set(),
+			other: /* @__PURE__ */ new Set()
+		};
+		for (const file of changedFiles) {
+			const entry = runtimeSourcesByFile.get(file);
+			if (entry) runtimeAffectingChangedByType[entry.type].add(file);
+		}
+		return {
+			entries: [...runtimeSourcesByFile.entries()].map(([file, entry]) => ({
+				file,
+				output: {
+					fileName: file,
+					source: entry.source,
+					type: "asset"
+				},
+				source: entry.source,
+				type: entry.type
+			})),
+			jsEntries: /* @__PURE__ */ new Map(),
+			sourceHashByFile: /* @__PURE__ */ new Map(),
+			runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
+			runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+			changedByType: {
+				html: /* @__PURE__ */ new Set(),
+				js: /* @__PURE__ */ new Set(),
+				css: /* @__PURE__ */ new Set(),
+				other: /* @__PURE__ */ new Set()
+			},
+			runtimeAffectingChangedByType,
+			processFiles: {
+				html: /* @__PURE__ */ new Set(),
+				js: /* @__PURE__ */ new Set(),
+				css: /* @__PURE__ */ new Set()
+			},
+			linkedImpactsByEntry: /* @__PURE__ */ new Map()
+		};
+	}
+	async function refreshRuntimeSetForSource(file, rawSource, type) {
+		const filename = node_path.default.resolve(file.path);
+		const hash = cache.computeHash(rawSource);
+		const changed = runtimeSourceHashByFile.get(filename) !== hash;
+		runtimeSourceHashByFile.set(filename, hash);
+		runtimeSourcesByFile.set(filename, {
+			source: rawSource,
+			type
+		});
+		if (!changed && runtimeSetInitialized) return runtimeSet;
+		if (runtimeState.twPatcher.majorVersion === 4 && !runtimeSetDirty) try {
+			runtimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, createRuntimeSnapshot([filename]));
+			runtimeSetInitialized = true;
+			return runtimeSet;
+		} catch (error) {
+			debug("gulp incremental runtime set sync failed, fallback to collect: %O", error);
+			await bundleRuntimeClassSetManager.reset();
+		}
+		return refreshRuntimeSet({ forceCollect: true });
+	}
+	async function refreshGulpSourceCandidates(forceRefresh = false) {
+		if (runtimeState.twPatcher.majorVersion !== 3) return /* @__PURE__ */ new Set();
+		const root = opts.tailwindcssBasedir ?? node_process.default.cwd();
+		const sourceScan = await require_v3_engine.resolveViteSourceScanEntries(opts, runtimeState.twPatcher, { root });
+		const nextSignature = cache.computeHash(JSON.stringify({
+			root,
+			entries: sourceScan?.entries,
+			inlineCandidates: sourceScan?.inlineCandidates ? {
+				included: [...sourceScan.inlineCandidates.included].sort(),
+				excluded: [...sourceScan.inlineCandidates.excluded].sort()
+			} : void 0,
+			explicit: sourceScan?.explicit ?? false,
+			dependencies: [...sourceScan?.dependencies ?? []].sort()
+		}));
+		if (!forceRefresh && cachedGulpSourceCandidateSignature === nextSignature && cachedGulpSourceCandidates) return cachedGulpSourceCandidates;
+		const collector = require_source_candidates.createSourceCandidateCollector();
+		await collector.scanRoot({
+			entries: sourceScan?.entries,
+			root
+		});
+		collector.syncInline(sourceScan?.inlineCandidates);
+		cachedGulpSourceCandidateSignature = nextSignature;
+		cachedGulpSourceCandidates = sourceScan?.entries ? collector.valuesForEntries(sourceScan.entries) : collector.values();
+		return cachedGulpSourceCandidates;
+	}
+	function createRuntimeSetHash(rawSource, nextRuntimeSet) {
+		return cache.computeHash([
+			rawSource,
+			require_v3_engine.getRuntimeClassSetSignature(runtimeState.twPatcher),
+			[...nextRuntimeSet].sort().join("\n")
+		].join("\n\n"));
+	}
+	async function registerAutoCssSource(file, rawSource) {
+		if (hasInitialTailwindCssRoots || (runtimeState.twPatcher.majorVersion ?? 0) < 4 || !file.path || !require_incremental_runtime_class_set.hasTailwindRootDirectives(rawSource)) return false;
+		const sourceCss = require_incremental_runtime_class_set.normalizeTailwindSourceForGenerator(rawSource, { importFallback: true });
+		if (!require_tailwindcss.upsertTailwindV4CssSource(opts, {
+			file: node_path.default.resolve(file.path),
+			css: sourceCss
+		})) return false;
+		runtimeSetInitialized = false;
+		runtimeSetDirty = true;
+		await bundleRuntimeClassSetManager.reset();
+		debug("detected tailwindcss v4 css source from gulp css file: %s", file.path);
+		return true;
+	}
 	function resolveWithExtensions(base) {
 		for (const ext of MODULE_EXTENSIONS) {
 			const candidate = `${base}${ext}`;
@@ -106,12 +227,14 @@ function createPlugins(options = {}) {
 		if (!cachedDefaultModuleGraphOptions) cachedDefaultModuleGraphOptions = createModuleGraphOptionsFor();
 		return cachedDefaultModuleGraphOptions;
 	}
-	function createVinylTransform(handler) {
+	function createVinylTransform(phase, handler) {
 		return new Transform({
 			objectMode: true,
 			async transform(file, _encoding, callback) {
+				const hmrTimingStartedAt = performance.now();
 				try {
 					await handler(file);
+					require_incremental_runtime_class_set.emitHmrTiming("gulp", phase, performance.now() - hmrTimingStartedAt, { file: file.relative || node_path.default.basename(file.path) });
 					callback(null, file);
 				} catch (error) {
 					callback(error, file);
@@ -124,12 +247,12 @@ function createPlugins(options = {}) {
 		if (!options || Object.keys(options).length === 0) {
 			let cached = defaultStyleHandlerOptionsCache.get(majorVersion);
 			if (!cached) {
-				cached = { majorVersion: runtimeState.twPatcher.majorVersion };
+				cached = runtimeState.twPatcher.majorVersion === void 0 ? {} : { majorVersion: runtimeState.twPatcher.majorVersion };
 				defaultStyleHandlerOptionsCache.set(majorVersion, cached);
 			}
 			return cached;
 		}
-		return {
+		return runtimeState.twPatcher.majorVersion === void 0 ? { ...options } : {
 			majorVersion: runtimeState.twPatcher.majorVersion,
 			...options
 		};
@@ -164,15 +287,28 @@ function createPlugins(options = {}) {
 			...options
 		};
 	}
-	const transformWxss = (options = {}) => createVinylTransform(async (file) => {
+	const transformWxss = (options = {}) => createVinylTransform("css", async (file) => {
 		if (!file.contents) return;
-		await refreshRuntimeState(true);
-		await runtimeState.patchPromise;
 		const rawSource = file.contents.toString();
-		await require_generator_css.processCachedTask({
+		const cssSourceChanged = await registerAutoCssSource(file, rawSource);
+		const isMainChunk = opts.mainCssChunkMatcher(resolveGulpMatcherName(file), opts.appType);
+		const shouldUseGenerator = runtimeState.twPatcher.majorVersion !== 3 || require_incremental_runtime_class_set.hasTailwindRootDirectives(rawSource);
+		let nextRuntimeSet = await refreshRuntimeSet({
+			forceRefresh: cssSourceChanged,
+			forceCollect: cssSourceChanged || runtimeState.twPatcher.majorVersion !== 4 && isMainChunk,
+			clearCache: cssSourceChanged
+		});
+		if (runtimeState.twPatcher.majorVersion === 3 && isMainChunk && shouldUseGenerator) {
+			const sourceCandidates = await refreshGulpSourceCandidates(cssSourceChanged);
+			if (sourceCandidates.size > 0) {
+				nextRuntimeSet = new Set([...nextRuntimeSet, ...sourceCandidates]);
+				runtimeSet = nextRuntimeSet;
+			}
+		}
+		await require_incremental_runtime_class_set.processCachedTask({
 			cache,
 			cacheKey: file.path,
-			rawSource,
+			hash: createRuntimeSetHash(rawSource, nextRuntimeSet),
 			applyResult(source) {
 				file.contents = node_buffer.Buffer.from(source);
 			},
@@ -180,42 +316,42 @@ function createPlugins(options = {}) {
 				debug("css cache hit: %s", file.path);
 			},
 			async transform() {
-				await runtimeState.patchPromise;
+				await runtimeState.readyPromise;
 				const cssHandlerOptions = resolveWxssFileHandlerOptions(file, options);
-				const css = (await require_generator_css.generateCssByGenerator({
+				const css = (shouldUseGenerator ? await require_incremental_runtime_class_set.generateCssByGenerator({
 					opts,
 					runtimeState,
-					runtime: await refreshRuntimeSet(false),
+					runtime: nextRuntimeSet,
 					rawSource,
 					file: file.path,
 					cssHandlerOptions,
 					cssUserHandlerOptions: resolveWxssUserHandlerOptions(options),
 					styleHandler,
 					debug
-				}))?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css;
+				}) : void 0)?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css;
 				debug("css handle: %s", file.path);
 				return { result: css };
 			}
 		});
 	});
-	const transformJs = (options = {}) => createVinylTransform(async (file) => {
+	const transformJs = (options = {}) => createVinylTransform("js", async (file) => {
 		if (!file.contents) return;
-		await refreshRuntimeSet(false);
-		await runtimeState.patchPromise;
 		const filename = node_path.default.resolve(file.path);
+		const rawSource = file.contents.toString();
+		await refreshRuntimeSetForSource(file, rawSource, "js");
+		await runtimeState.readyPromise;
 		const moduleGraph = resolveModuleGraphOptions(options.moduleGraph);
 		const handlerOptions = {
 			...options,
 			filename,
 			moduleGraph,
-			tailwindcssMajorVersion: runtimeState.twPatcher.majorVersion,
 			babelParserOptions: {
 				...options?.babelParserOptions ?? {},
 				sourceFilename: filename
 			}
 		};
-		const rawSource = file.contents.toString();
-		await require_generator_css.processCachedTask({
+		if (runtimeState.twPatcher.majorVersion !== void 0) handlerOptions.tailwindcssMajorVersion = runtimeState.twPatcher.majorVersion;
+		await require_incremental_runtime_class_set.processCachedTask({
 			cache,
 			cacheKey: file.path,
 			rawSource,
@@ -226,21 +362,24 @@ function createPlugins(options = {}) {
 				debug("js cache hit: %s", file.path);
 			},
 			async transform() {
-				await runtimeState.patchPromise;
+				await runtimeState.readyPromise;
 				const currentSource = file.contents?.toString() ?? rawSource;
-				if (require_recorder.shouldSkipJsTransform(currentSource, handlerOptions)) return { result: currentSource };
+				if (require_precheck.shouldSkipJsTransform(currentSource, {
+					...handlerOptions,
+					classNameSet: runtimeSet
+				})) return { result: currentSource };
 				const { code } = await jsHandler(currentSource, runtimeSet, handlerOptions);
 				debug("js handle: %s", file.path);
 				return { result: code };
 			}
 		});
 	});
-	const transformWxml = (options = {}) => createVinylTransform(async (file) => {
+	const transformWxml = (options = {}) => createVinylTransform("html", async (file) => {
 		if (!file.contents) return;
-		await refreshRuntimeSet(false);
-		await runtimeState.patchPromise;
 		const rawSource = file.contents.toString();
-		await require_generator_css.processCachedTask({
+		await refreshRuntimeSetForSource(file, rawSource, "html");
+		await runtimeState.readyPromise;
+		await require_incremental_runtime_class_set.processCachedTask({
 			cache,
 			cacheKey: file.path,
 			rawSource,
@@ -251,7 +390,7 @@ function createPlugins(options = {}) {
 				debug("html cache hit: %s", file.path);
 			},
 			async transform() {
-				await runtimeState.patchPromise;
+				await runtimeState.readyPromise;
 				const code = await templateHandler(rawSource, resolveWxmlHandlerOptions(options));
 				debug("html handle: %s", file.path);
 				return { result: code };