weapp-tailwindcss 5.0.5 → 5.0.7

package/dist/gulp-_7p1Z2vc.js

@@ -0,0 +1,473 @@
+const require_chunk = require("./chunk-emK7D4bc.js");
+const require_v3_engine = require("./v3-engine-CEMXFegG.js");
+const require_precheck = require("./precheck-fhIkzCSU.js");
+const require_tailwindcss = require("./tailwindcss-vswd1gc3.js");
+const require_hmr_timing = require("./hmr-timing-BKQNRxHr.js");
+let node_process = require("node:process");
+node_process = require_chunk.__toESM(node_process);
+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_buffer = require("node:buffer");
+let node_stream = require("node:stream");
+node_stream = require_chunk.__toESM(node_stream);
+//#region src/bundlers/gulp/module-graph.ts
+const MODULE_EXTENSIONS = [
+	".js",
+	".mjs",
+	".cjs",
+	".ts",
+	".tsx",
+	".jsx"
+];
+function resolveWithExtensions(base) {
+	for (const ext of MODULE_EXTENSIONS) {
+		const candidate = `${base}${ext}`;
+		try {
+			if (node_fs.default.statSync(candidate).isFile()) return candidate;
+		} catch {
+			continue;
+		}
+	}
+}
+function resolveLocalModuleCandidate(base) {
+	try {
+		const stat = node_fs.default.statSync(base);
+		if (stat.isFile()) return base;
+		if (stat.isDirectory()) {
+			const resolvedIndex = resolveWithExtensions(node_path.default.join(base, "index"));
+			if (resolvedIndex) return resolvedIndex;
+		}
+	} catch {}
+	if (!node_path.default.extname(base)) return resolveWithExtensions(base);
+}
+function createGulpModuleGraphOptions(opts) {
+	return {
+		resolve(specifier, importer) {
+			if (!specifier) return;
+			if (!specifier.startsWith(".") && !node_path.default.isAbsolute(specifier)) return;
+			return resolveLocalModuleCandidate(node_path.default.resolve(node_path.default.dirname(importer), specifier));
+		},
+		load(id) {
+			try {
+				return node_fs.default.readFileSync(id, "utf8");
+			} catch {
+				return;
+			}
+		},
+		filter(id) {
+			const relative = node_path.default.relative(node_process.default.cwd(), id);
+			return opts.jsMatcher(relative) || opts.wxsMatcher(relative);
+		}
+	};
+}
+//#endregion
+//#region src/bundlers/gulp/runtime-snapshot.ts
+function createGulpRuntimeSnapshot(runtimeSourcesByFile, 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(),
+		hasOmittedKnownFiles: false,
+		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()
+	};
+}
+//#endregion
+//#region src/bundlers/gulp/vinyl-transform.ts
+const Transform = node_stream.default.Transform;
+function createVinylTransform(phase, handler) {
+	return new Transform({
+		objectMode: true,
+		async transform(file, _encoding, callback) {
+			const hmrTimingStartedAt = performance.now();
+			try {
+				await handler(file);
+				require_hmr_timing.emitHmrTiming("gulp", phase, performance.now() - hmrTimingStartedAt, { file: file.relative || node_path.default.basename(file.path) });
+				callback(null, file);
+			} catch (error) {
+				callback(error, file);
+			}
+		}
+	});
+}
+//#endregion
+//#region src/bundlers/gulp/index.ts
+const debug = require_v3_engine.createDebug();
+/**
+* @name weapp-tw-gulp
+* @description gulp版本weapp-tw插件
+* @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
+*/
+function createPlugins(options = {}) {
+	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,
+		readyPromise,
+		refreshTailwindcssPatcher
+	};
+	const defaultStyleHandlerOptionsCache = /* @__PURE__ */ new Map();
+	let cachedDefaultTemplateHandlerOptions;
+	let cachedDefaultTemplateRuntimeSet;
+	let cachedDefaultModuleGraphOptions;
+	let cachedGulpSourceCandidateGetter;
+	let cachedGulpSourceCandidateSourceGetter;
+	let runtimeSetInitialized = false;
+	let runtimeSetDirty = false;
+	const runtimeSourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeSourcesByFile = /* @__PURE__ */ new Map();
+	let cachedGulpSourceCandidates;
+	let cachedGulpSourceCandidateSignature;
+	const sourceCandidateExtractor = initialTwPatcher.majorVersion === 3 ? require_hmr_timing.createTailwindV3DefaultExtractor() : void 0;
+	const bundleRuntimeClassSetManager = options.__internalGulpRuntimeClassSetManager ?? require_hmr_timing.createBundleRuntimeClassSetManager();
+	function invalidateGulpSourceCandidates() {
+		cachedGulpSourceCandidates = void 0;
+		cachedGulpSourceCandidateSignature = void 0;
+		cachedGulpSourceCandidateGetter = void 0;
+		cachedGulpSourceCandidateSourceGetter = void 0;
+	}
+	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;
+	}
+	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 && runtimeState.twPatcher.majorVersion === 4) invalidateGulpSourceCandidates();
+		if (!changed && runtimeSetInitialized) return runtimeSet;
+		if (runtimeState.twPatcher.majorVersion === 4 && !runtimeSetDirty) try {
+			runtimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, createGulpRuntimeSnapshot(runtimeSourcesByFile, [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_hmr_timing.createSourceCandidateCollector({
+			bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
+			extractor: sourceCandidateExtractor
+		});
+		await collector.scanRoot({
+			entries: sourceScan?.entries,
+			root
+		});
+		collector.syncInline(sourceScan?.inlineCandidates);
+		cachedGulpSourceCandidateSignature = nextSignature;
+		cachedGulpSourceCandidateGetter = (entries) => collector.valuesForEntries(entries);
+		cachedGulpSourceCandidateSourceGetter = (entries) => collector.sourcesForEntries(entries);
+		cachedGulpSourceCandidates = sourceScan?.entries ? collector.valuesForEntries(sourceScan.entries) : collector.values();
+		return cachedGulpSourceCandidates;
+	}
+	async function refreshGulpV4SourceCandidates(forceRefresh = false) {
+		if (runtimeState.twPatcher.majorVersion !== 4) {
+			cachedGulpSourceCandidateGetter = void 0;
+			cachedGulpSourceCandidateSourceGetter = void 0;
+			return;
+		}
+		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 && cachedGulpSourceCandidateGetter) return cachedGulpSourceCandidateGetter;
+		const collector = require_hmr_timing.createSourceCandidateCollector({ bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues });
+		await collector.scanRoot({
+			entries: sourceScan?.entries,
+			explicit: sourceScan?.explicit,
+			root
+		});
+		collector.syncInline(sourceScan?.inlineCandidates);
+		cachedGulpSourceCandidateSignature = nextSignature;
+		cachedGulpSourceCandidateGetter = (entries) => collector.valuesForEntries(entries);
+		cachedGulpSourceCandidateSourceGetter = (entries) => collector.sourcesForEntries(entries);
+		return cachedGulpSourceCandidateGetter;
+	}
+	function createRuntimeSetHash(rawSource, nextRuntimeSet, sourceTraceSignature) {
+		return cache.computeHash([
+			rawSource,
+			require_v3_engine.getRuntimeClassSetSignature(runtimeState.twPatcher),
+			[...nextRuntimeSet].sort().join("\n"),
+			sourceTraceSignature ?? "css-source-trace:0"
+		].join("\n\n"));
+	}
+	async function registerAutoCssSource(file, rawSource) {
+		if (hasInitialTailwindCssRoots || (runtimeState.twPatcher.majorVersion ?? 0) < 4 || !file.path || !require_v3_engine.hasTailwindRootDirectives(rawSource)) return false;
+		const sourceFile = node_path.default.resolve(file.path);
+		const sourceCss = require_v3_engine.normalizeTailwindSourceForGenerator(require_v3_engine.normalizeTailwindConfigDirectives(rawSource, node_path.default.dirname(sourceFile)), { importFallback: true });
+		if (!require_tailwindcss.upsertTailwindV4CssSource(opts, {
+			file: sourceFile,
+			base: node_path.default.dirname(sourceFile),
+			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 resolveModuleGraphOptions(moduleGraph) {
+		if (moduleGraph) return moduleGraph;
+		if (!cachedDefaultModuleGraphOptions) cachedDefaultModuleGraphOptions = createGulpModuleGraphOptions(opts);
+		return cachedDefaultModuleGraphOptions;
+	}
+	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 || node_path.default.basename(file.path)).replaceAll(node_path.default.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("css", async (file) => {
+		if (!file.contents) return;
+		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 || require_v3_engine.hasTailwindRootDirectives(rawSource);
+		const gulpV4SourceCandidates = shouldUseGenerator && runtimeState.twPatcher.majorVersion === 4 ? await refreshGulpV4SourceCandidates(cssSourceChanged) : void 0;
+		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;
+			}
+		}
+		const sourceTraceTokenSources = cachedGulpSourceCandidateSourceGetter ? require_hmr_timing.createCssTokenSourceMap(cachedGulpSourceCandidateSourceGetter(void 0), opts) : void 0;
+		const sourceTraceSignature = require_hmr_timing.createCssSourceTraceCacheSignature(sourceTraceTokenSources, opts);
+		await require_hmr_timing.processCachedTask({
+			cache,
+			cacheKey: file.path,
+			hash: createRuntimeSetHash(rawSource, nextRuntimeSet, sourceTraceSignature),
+			applyResult(source) {
+				file.contents = node_buffer.Buffer.from(source);
+			},
+			onCacheHit() {
+				debug("css cache hit: %s", file.path);
+			},
+			async transform() {
+				await runtimeState.readyPromise;
+				const cssHandlerOptions = resolveWxssFileHandlerOptions(file, options);
+				const css = require_hmr_timing.annotateCssSourceTrace((shouldUseGenerator ? await require_hmr_timing.generateCssByGenerator({
+					opts,
+					runtimeState,
+					runtime: nextRuntimeSet,
+					rawSource,
+					file: file.path,
+					cssHandlerOptions,
+					cssUserHandlerOptions: resolveWxssUserHandlerOptions(options),
+					getSourceCandidatesForEntries: gulpV4SourceCandidates,
+					styleHandler,
+					debug
+				}) : void 0)?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css, {
+					opts,
+					tokenSources: sourceTraceTokenSources
+				});
+				debug("css handle: %s", file.path);
+				return { result: css };
+			}
+		});
+	});
+	const transformJs = (options = {}) => createVinylTransform("js", async (file) => {
+		if (!file.contents) return;
+		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,
+			babelParserOptions: {
+				...options?.babelParserOptions ?? {},
+				sourceFilename: filename
+			}
+		};
+		if (runtimeState.twPatcher.majorVersion !== void 0) handlerOptions.tailwindcssMajorVersion = runtimeState.twPatcher.majorVersion;
+		await require_hmr_timing.processCachedTask({
+			cache,
+			cacheKey: file.path,
+			rawSource,
+			applyResult(source) {
+				file.contents = node_buffer.Buffer.from(source);
+			},
+			onCacheHit() {
+				debug("js cache hit: %s", file.path);
+			},
+			async transform() {
+				await runtimeState.readyPromise;
+				const currentSource = file.contents?.toString() ?? rawSource;
+				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("html", async (file) => {
+		if (!file.contents) return;
+		const rawSource = file.contents.toString();
+		await refreshRuntimeSetForSource(file, rawSource, "html");
+		await runtimeState.readyPromise;
+		await require_hmr_timing.processCachedTask({
+			cache,
+			cacheKey: file.path,
+			rawSource,
+			applyResult(source) {
+				file.contents = node_buffer.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
+Object.defineProperty(exports, "createPlugins", {
+	enumerable: true,
+	get: function() {
+		return createPlugins;
+	}
+});