weapp-tailwindcss 4.12.0 → 5.0.0-next.10

package/dist/gulp.mjs

@@ -1,13 +1,362 @@
-import {
-  createPlugins
-} from "./chunk-XZP3MREK.mjs";
-import "./chunk-76S2EME4.mjs";
-import "./chunk-KGTVD4EP.mjs";
-import "./chunk-PCDYXXSK.mjs";
-import "./chunk-XAKAD2CR.mjs";
-import "./chunk-OOHJLO5M.mjs";
-import "./chunk-NNOQDMUP.mjs";
-export {
-  createPlugins,
-  createPlugins as weappTailwindcss
-};
+import { n as getRuntimeClassSetSignature } from "./cache-CHs4DXui.mjs";
+import { n as createDebug } from "./runtime-patch-CwN5ya72.mjs";
+import { a as hasTailwindRootDirectives, i as processCachedTask, n as generateCssByGenerator, t as createBundleRuntimeClassSetManager } from "./incremental-runtime-class-set-BgMW6wf2.mjs";
+import { _ as ensureRuntimeClassSet, g as createTailwindRuntimeReadyPromise, n as getCompilerContext, t as shouldSkipJsTransform } from "./precheck-B4RH6ZNN.mjs";
+import { c as upsertTailwindV4CssSource, s as hasConfiguredTailwindV4CssRoots } from "./tailwindcss-C5IgPlQ0.mjs";
+import path from "node:path";
+import process from "node:process";
+import fs from "node:fs";
+import { Buffer } from "node:buffer";
+import stream from "node:stream";
+//#region src/bundlers/gulp/index.ts
+const debug = createDebug();
+const Transform = stream.Transform;
+/**
+* @name weapp-tw-gulp
+* @description gulp版本weapp-tw插件
+* @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
+*/
+function createPlugins(options = {}) {
+	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,
+		readyPromise,
+		refreshTailwindcssPatcher
+	};
+	const defaultStyleHandlerOptionsCache = /* @__PURE__ */ new Map();
+	let cachedDefaultTemplateHandlerOptions;
+	let cachedDefaultTemplateRuntimeSet;
+	let cachedDefaultModuleGraphOptions;
+	const MODULE_EXTENSIONS = [
+		".js",
+		".mjs",
+		".cjs",
+		".ts",
+		".tsx",
+		".jsx"
+	];
+	let runtimeSetInitialized = false;
+	let runtimeSetDirty = false;
+	const runtimeSourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeSourcesByFile = /* @__PURE__ */ new Map();
+	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,
+			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 });
+	}
+	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;
+		if (!upsertTailwindV4CssSource(opts, {
+			file: path.resolve(file.path),
+			css: rawSource
+		})) 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}`;
+			try {
+				if (fs.statSync(candidate).isFile()) return candidate;
+			} catch {
+				continue;
+			}
+		}
+	}
+	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);
+	}
+	function createModuleGraphOptionsFor() {
+		return {
+			resolve(specifier, importer) {
+				if (!specifier) return;
+				if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) return;
+				return resolveLocalModuleCandidate(path.resolve(path.dirname(importer), specifier));
+			},
+			load(id) {
+				try {
+					return fs.readFileSync(id, "utf8");
+				} catch {
+					return;
+				}
+			},
+			filter(id) {
+				const relative = path.relative(process.cwd(), id);
+				return opts.jsMatcher(relative) || opts.wxsMatcher(relative);
+			}
+		};
+	}
+	function resolveModuleGraphOptions(moduleGraph) {
+		if (moduleGraph) return moduleGraph;
+		if (!cachedDefaultModuleGraphOptions) cachedDefaultModuleGraphOptions = createModuleGraphOptionsFor();
+		return cachedDefaultModuleGraphOptions;
+	}
+	function createVinylTransform(handler) {
+		return new Transform({
+			objectMode: true,
+			async transform(file, _encoding, callback) {
+				try {
+					await handler(file);
+					callback(null, file);
+				} catch (error) {
+					callback(error, file);
+				}
+			}
+		});
+	}
+	function resolveWxssHandlerOptions(options) {
+		const majorVersion = runtimeState.twPatcher.majorVersion ?? "unknown";
+		if (!options || Object.keys(options).length === 0) {
+			let cached = defaultStyleHandlerOptionsCache.get(majorVersion);
+			if (!cached) {
+				cached = runtimeState.twPatcher.majorVersion === void 0 ? {} : { majorVersion: runtimeState.twPatcher.majorVersion };
+				defaultStyleHandlerOptionsCache.set(majorVersion, cached);
+			}
+			return cached;
+		}
+		return runtimeState.twPatcher.majorVersion === void 0 ? { ...options } : {
+			majorVersion: runtimeState.twPatcher.majorVersion,
+			...options
+		};
+	}
+	function resolveGulpMatcherName(file) {
+		return (file.relative || path.basename(file.path)).replaceAll(path.sep, "/");
+	}
+	function resolveWxssFileHandlerOptions(file, options) {
+		const resolved = resolveWxssHandlerOptions(options);
+		if (resolved.isMainChunk !== void 0) return resolved;
+		return {
+			...resolved,
+			isMainChunk: opts.mainCssChunkMatcher(resolveGulpMatcherName(file), opts.appType)
+		};
+	}
+	function resolveWxssUserHandlerOptions(options) {
+		return {
+			...resolveWxssHandlerOptions(options),
+			isMainChunk: false
+		};
+	}
+	function resolveWxmlHandlerOptions(options) {
+		if (!options || Object.keys(options).length === 0) {
+			if (cachedDefaultTemplateRuntimeSet !== runtimeSet || !cachedDefaultTemplateHandlerOptions) {
+				cachedDefaultTemplateRuntimeSet = runtimeSet;
+				cachedDefaultTemplateHandlerOptions = { runtimeSet };
+			}
+			return cachedDefaultTemplateHandlerOptions;
+		}
+		return {
+			runtimeSet,
+			...options
+		};
+	}
+	const transformWxss = (options = {}) => createVinylTransform(async (file) => {
+		if (!file.contents) return;
+		const rawSource = file.contents.toString();
+		const cssSourceChanged = await registerAutoCssSource(file, rawSource);
+		const nextRuntimeSet = await refreshRuntimeSet({
+			forceRefresh: cssSourceChanged,
+			forceCollect: cssSourceChanged || opts.mainCssChunkMatcher(resolveGulpMatcherName(file), opts.appType),
+			clearCache: cssSourceChanged
+		});
+		await processCachedTask({
+			cache,
+			cacheKey: file.path,
+			hash: createRuntimeSetHash(rawSource, nextRuntimeSet),
+			applyResult(source) {
+				file.contents = Buffer.from(source);
+			},
+			onCacheHit() {
+				debug("css cache hit: %s", file.path);
+			},
+			async transform() {
+				await runtimeState.readyPromise;
+				const cssHandlerOptions = resolveWxssFileHandlerOptions(file, options);
+				const css = (await generateCssByGenerator({
+					opts,
+					runtimeState,
+					runtime: nextRuntimeSet,
+					rawSource,
+					file: file.path,
+					cssHandlerOptions,
+					cssUserHandlerOptions: resolveWxssUserHandlerOptions(options),
+					styleHandler,
+					debug
+				}))?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css;
+				debug("css handle: %s", file.path);
+				return { result: css };
+			}
+		});
+	});
+	const transformJs = (options = {}) => createVinylTransform(async (file) => {
+		if (!file.contents) return;
+		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,
+			babelParserOptions: {
+				...options?.babelParserOptions ?? {},
+				sourceFilename: filename
+			}
+		};
+		if (runtimeState.twPatcher.majorVersion !== void 0) handlerOptions.tailwindcssMajorVersion = runtimeState.twPatcher.majorVersion;
+		await processCachedTask({
+			cache,
+			cacheKey: file.path,
+			rawSource,
+			applyResult(source) {
+				file.contents = Buffer.from(source);
+			},
+			onCacheHit() {
+				debug("js cache hit: %s", file.path);
+			},
+			async transform() {
+				await runtimeState.readyPromise;
+				const currentSource = file.contents?.toString() ?? rawSource;
+				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) => {
+		if (!file.contents) return;
+		const rawSource = file.contents.toString();
+		await refreshRuntimeSetForSource(file, rawSource, "html");
+		await runtimeState.readyPromise;
+		await processCachedTask({
+			cache,
+			cacheKey: file.path,
+			rawSource,
+			applyResult(source) {
+				file.contents = Buffer.from(source);
+			},
+			onCacheHit() {
+				debug("html cache hit: %s", file.path);
+			},
+			async transform() {
+				await runtimeState.readyPromise;
+				const code = await templateHandler(rawSource, resolveWxmlHandlerOptions(options));
+				debug("html handle: %s", file.path);
+				return { result: code };
+			}
+		});
+	});
+	return {
+		transformWxss,
+		transformWxml,
+		transformJs
+	};
+}
+//#endregion
+export { createPlugins as WeappTailwindcss, createPlugins, createPlugins as weappTailwindcss };