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

package/dist/gulp.mjs

@@ -1,9 +1,12 @@
-import { _ as refreshTailwindRuntimeState, g as ensureRuntimeClassSet, n as shouldSkipJsTransform, r as getCompilerContext, t as setupPatchRecorder, v as createDebug } from "./recorder-XdFvVASS.mjs";
-import { i as processCachedTask, t as generateCssByGenerator } from "./generator-css-Bwy_Uz89.mjs";
+import { b as ensureRuntimeClassSet, n as getCompilerContext, t as shouldSkipJsTransform, y as createTailwindRuntimeReadyPromise } from "./precheck-D7K12zeX.mjs";
+import { B as createDebug, _ as resolveViteSourceScanEntries, l as getRuntimeClassSetSignature } from "./v3-engine-DcvCCHfs.mjs";
+import { i as generateCssByGenerator, l as normalizeTailwindSourceForGenerator, o as processCachedTask, r as emitHmrTiming, s as hasTailwindRootDirectives, t as createBundleRuntimeClassSetManager } from "./incremental-runtime-class-set-BdZHkoTs.mjs";
+import { c as upsertTailwindV4CssSource, s as hasConfiguredTailwindV4CssRoots } from "./tailwindcss-C7dJHZ0G.mjs";
+import { t as createSourceCandidateCollector } from "./source-candidates-CX2ozpKM.mjs";
+import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import { Buffer } from "node:buffer";
-import fs from "node:fs";
 import stream from "node:stream";
 //#region src/bundlers/gulp/index.ts
 const debug = createDebug();
@@ -14,18 +17,18 @@ const Transform = stream.Transform;
 * @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
 */
 function createPlugins(options = {}) {
-	const opts = getCompilerContext(options);
-	const { templateHandler, styleHandler, jsHandler, cache, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = opts;
-	const patchRecorderState = setupPatchRecorder(initialTwPatcher, opts.tailwindcssBasedir, {
-		source: "runtime",
-		cwd: opts.tailwindcssBasedir ?? process.cwd()
+	const hasInitialTailwindCssRoots = hasConfiguredTailwindV4CssRoots(options);
+	const opts = getCompilerContext({
+		...options,
+		__internalDeferMissingCssEntriesWarning: true
 	});
+	const { templateHandler, styleHandler, jsHandler, cache, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = opts;
+	const readyPromise = 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;
@@ -40,20 +43,138 @@ function createPlugins(options = {}) {
 		".jsx"
 	];
 	let runtimeSetInitialized = false;
-	async function refreshRuntimeState(force) {
-		await refreshTailwindRuntimeState(runtimeState, force);
-	}
-	async function refreshRuntimeSet(force = false) {
-		if (!force && runtimeSetInitialized) return runtimeSet;
+	let runtimeSetDirty = false;
+	const runtimeSourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeSourcesByFile = /* @__PURE__ */ new Map();
+	let cachedGulpSourceCandidates;
+	let cachedGulpSourceCandidateSignature;
+	const bundleRuntimeClassSetManager = options.__internalGulpRuntimeClassSetManager ?? 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 ensureRuntimeClassSet(runtimeState, {
-			forceRefresh: force,
-			forceCollect: force,
-			clearCache: force,
+			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 = path.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 ?? process.cwd();
+		const sourceScan = await 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 = 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,
+			getRuntimeClassSetSignature(runtimeState.twPatcher),
+			[...nextRuntimeSet].sort().join("\n")
+		].join("\n\n"));
+	}
+	async function registerAutoCssSource(file, rawSource) {
+		if (hasInitialTailwindCssRoots || (runtimeState.twPatcher.majorVersion ?? 0) < 4 || !file.path || !hasTailwindRootDirectives(rawSource)) return false;
+		const sourceCss = normalizeTailwindSourceForGenerator(rawSource, { importFallback: true });
+		if (!upsertTailwindV4CssSource(opts, {
+			file: path.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}`;
@@ -100,12 +221,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);
+					emitHmrTiming("gulp", phase, performance.now() - hmrTimingStartedAt, { file: file.relative || path.basename(file.path) });
 					callback(null, file);
 				} catch (error) {
 					callback(error, file);
@@ -118,12 +241,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
 		};
@@ -158,15 +281,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();
+		const cssSourceChanged = await registerAutoCssSource(file, rawSource);
+		const isMainChunk = opts.mainCssChunkMatcher(resolveGulpMatcherName(file), opts.appType);
+		const shouldUseGenerator = runtimeState.twPatcher.majorVersion !== 3 || 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 processCachedTask({
 			cache,
 			cacheKey: file.path,
-			rawSource,
+			hash: createRuntimeSetHash(rawSource, nextRuntimeSet),
 			applyResult(source) {
 				file.contents = Buffer.from(source);
 			},
@@ -174,41 +310,41 @@ 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 generateCssByGenerator({
+				const css = (shouldUseGenerator ? await 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 = path.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();
+		if (runtimeState.twPatcher.majorVersion !== void 0) handlerOptions.tailwindcssMajorVersion = runtimeState.twPatcher.majorVersion;
 		await processCachedTask({
 			cache,
 			cacheKey: file.path,
@@ -220,20 +356,23 @@ 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 (shouldSkipJsTransform(currentSource, handlerOptions)) return { result: currentSource };
+				if (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 refreshRuntimeSetForSource(file, rawSource, "html");
+		await runtimeState.readyPromise;
 		await processCachedTask({
 			cache,
 			cacheKey: file.path,
@@ -245,7 +384,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 };