weapp-tailwindcss 5.0.2 → 5.0.4

package/dist/transform-FAxHXVZp.mjs

@@ -0,0 +1,255 @@
+import { c as createAttributeMatcher, d as _defineProperty, f as isClassContextLiteralPath, l as analyzeSource, m as babelParse, p as replaceWxml, s as generateCode, u as JsTokenUpdater } from "./precheck-lfenbOTF.mjs";
+import { splitCandidateTokens } from "tailwindcss-patch";
+import MagicString from "magic-string";
+import { NodeTypes } from "@vue/compiler-dom";
+import { parse } from "@vue/compiler-sfc";
+//#region src/uni-app-x/component-local-style.ts
+const EXPRESSION_WRAPPER_PREFIX = "(\n";
+const EXPRESSION_WRAPPER_SUFFIX = "\n)";
+const COMPONENT_RE = /(?:^|[/\\])components(?:[/\\].+)?\.(?:uvue|nvue)$/;
+function createStableHash(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function extractLiteralValue(path) {
+	if (path.isStringLiteral()) return {
+		literal: path.node.value,
+		offset: 1
+	};
+	return {
+		literal: typeof path.node.value === "string" ? path.node.value : path.node.value.raw,
+		offset: 0
+	};
+}
+function createAlias(fileId, utility, index) {
+	return `wtu-${createStableHash(`${fileId}:${utility}`)}-${index.toString(36)}`;
+}
+function isRuntimeCandidate(candidate, runtimeSet) {
+	if (!runtimeSet || runtimeSet.size === 0) return false;
+	return runtimeSet.has(candidate) || runtimeSet.has(replaceWxml(candidate));
+}
+function shouldEnableComponentLocalStyle(id) {
+	return COMPONENT_RE.test(id);
+}
+var UniAppXComponentLocalStyleCollector = class {
+	constructor(fileId, runtimeSet) {
+		this.fileId = fileId;
+		this.runtimeSet = runtimeSet;
+		_defineProperty(this, "aliasByUtility", /* @__PURE__ */ new Map());
+		_defineProperty(this, "aliasByLookup", /* @__PURE__ */ new Map());
+	}
+	ensureAlias(utility) {
+		const cached = this.aliasByUtility.get(utility);
+		if (cached) return cached;
+		const alias = createAlias(this.fileId, utility, this.aliasByUtility.size);
+		this.aliasByUtility.set(utility, alias);
+		this.aliasByLookup.set(utility, alias);
+		this.aliasByLookup.set(replaceWxml(utility), alias);
+		return alias;
+	}
+	rewriteLiteral(literal, shouldInclude) {
+		const candidates = splitCandidateTokens(literal);
+		if (candidates.length === 0) return literal;
+		let rewritten = literal;
+		for (const candidate of candidates) {
+			if (!shouldInclude(candidate)) continue;
+			rewritten = rewritten.replace(candidate, this.ensureAlias(candidate));
+		}
+		return rewritten;
+	}
+	collectAndRewriteStaticClass(literal) {
+		return this.rewriteLiteral(literal, (candidate) => isRuntimeCandidate(candidate, this.runtimeSet));
+	}
+	collectRuntimeClasses(rawSource, options = {}) {
+		const wrapped = options.wrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
+		try {
+			const analysis = analyzeSource(babelParse(wrapped, {
+				plugins: ["typescript"],
+				sourceType: options.wrapExpression ? "module" : "unambiguous"
+			}), {}, void 0, false);
+			for (const path of analysis.targetPaths) {
+				const { literal } = extractLiteralValue(path);
+				const candidates = splitCandidateTokens(literal);
+				const classContext = options.wrapExpression || isClassContextLiteralPath(path);
+				for (const candidate of candidates) {
+					if (!candidate || !classContext && !isRuntimeCandidate(candidate, this.runtimeSet)) continue;
+					if (isRuntimeCandidate(candidate, this.runtimeSet)) this.ensureAlias(candidate);
+				}
+			}
+		} catch {}
+	}
+	rewriteTransformedCode(rawSource, options = {}) {
+		if (this.aliasByLookup.size === 0) return rawSource;
+		const wrapped = options.wrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
+		try {
+			const analysis = analyzeSource(babelParse(wrapped, {
+				plugins: ["typescript"],
+				sourceType: options.wrapExpression ? "module" : "unambiguous"
+			}), {}, void 0, false);
+			if (analysis.targetPaths.length === 0) return rawSource;
+			const updater = new JsTokenUpdater();
+			for (const path of analysis.targetPaths) {
+				const { literal, offset } = extractLiteralValue(path);
+				const candidates = splitCandidateTokens(literal);
+				if (candidates.length === 0) continue;
+				let rewritten = literal;
+				let mutated = false;
+				for (const candidate of candidates) {
+					const alias = this.aliasByLookup.get(candidate);
+					if (!alias) continue;
+					const replaced = rewritten.replace(candidate, alias);
+					if (replaced !== rewritten) {
+						rewritten = replaced;
+						mutated = true;
+					}
+				}
+				if (!mutated || typeof path.node.start !== "number" || typeof path.node.end !== "number") continue;
+				updater.addToken({
+					start: path.node.start + offset,
+					end: path.node.end - offset,
+					value: rewritten,
+					path
+				});
+			}
+			if (updater.length === 0) return rawSource;
+			const ms = new MagicString(wrapped);
+			updater.updateMagicString(ms);
+			if (options.wrapExpression) {
+				ms.remove(0, 2);
+				ms.remove(wrapped.length - 2, wrapped.length);
+			}
+			return ms.toString();
+		} catch {
+			return rawSource;
+		}
+	}
+	hasStyles() {
+		return this.aliasByUtility.size > 0;
+	}
+	toStyleBlock() {
+		if (!this.hasStyles()) return "";
+		const lines = ["<style scoped>"];
+		for (const [utility, alias] of this.aliasByUtility) {
+			lines.push(`.${alias} {`);
+			lines.push(`  @apply ${utility};`);
+			lines.push("}");
+		}
+		lines.push("</style>");
+		return `${lines.join("\n")}\n`;
+	}
+};
+//#endregion
+//#region src/uni-app-x/transform.ts
+function traverse(node, visitor) {
+	visitor(node);
+	if (Array.isArray(node.children)) {
+		for (const child of node.children) if (child && typeof child === "object" && "type" in child) traverse(child, visitor);
+	}
+}
+function updateStaticAttribute(ms, prop, content = prop.value?.content) {
+	if (!prop.value) return;
+	const start = prop.value.loc.start.offset + 1;
+	const end = prop.value.loc.end.offset - 1;
+	if (start < end) ms.update(start, end, replaceWxml(content ?? ""));
+}
+function updateStaticAttributeWithLocalStyle(ms, prop, collector, content = prop.value?.content) {
+	if (!prop.value) return;
+	const start = prop.value.loc.start.offset + 1;
+	const end = prop.value.loc.end.offset - 1;
+	if (start < end) ms.update(start, end, collector.collectAndRewriteStaticClass(content ?? ""));
+}
+function updateDirectiveExpression(ms, prop, jsHandler, runtimeSet) {
+	if (prop.exp?.type !== NodeTypes.SIMPLE_EXPRESSION) return;
+	const expression = prop.exp.content;
+	const start = prop.exp.loc.start.offset;
+	const end = prop.exp.loc.end.offset;
+	if (start >= end) return;
+	const generated = generateCode(expression, {
+		jsHandler,
+		runtimeSet,
+		wrapExpression: true
+	});
+	ms.update(start, end, generated);
+}
+function updateDirectiveExpressionWithLocalStyle(ms, prop, jsHandler, collector, runtimeSet) {
+	if (prop.exp?.type !== NodeTypes.SIMPLE_EXPRESSION) return;
+	const expression = prop.exp.content;
+	const start = prop.exp.loc.start.offset;
+	const end = prop.exp.loc.end.offset;
+	if (start >= end) return;
+	collector.collectRuntimeClasses(expression, { wrapExpression: true });
+	const generated = generateCode(expression, {
+		jsHandler,
+		runtimeSet,
+		wrapExpression: true
+	});
+	ms.update(start, end, collector.rewriteTransformedCode(generated, { wrapExpression: true }));
+}
+function shouldHandleAttribute(tag, attrName, disabledDefaultTemplateHandler, matchCustomAttribute) {
+	const lowerName = attrName.toLowerCase();
+	const shouldHandleDefault = !disabledDefaultTemplateHandler && lowerName === "class";
+	const shouldHandleCustom = matchCustomAttribute?.(tag, attrName) ?? false;
+	return {
+		shouldHandleDefault,
+		shouldHandleCustom,
+		shouldHandle: shouldHandleDefault || shouldHandleCustom
+	};
+}
+const defaultCreateJsHandlerOptions = { babelParserOptions: { plugins: ["typescript"] } };
+const UVUE_NVUE_RE = /\.(?:uvue|nvue)(?:\?.*)?$/;
+function transformUVue(code, id, jsHandler, runtimeSet, options = {}) {
+	if (!UVUE_NVUE_RE.test(id)) return;
+	const { customAttributesEntities, disabledDefaultTemplateHandler = false } = options;
+	const matchCustomAttribute = createAttributeMatcher(customAttributesEntities);
+	const ms = new MagicString(code);
+	const { descriptor, errors } = parse(code);
+	const localStyleCollector = options.enableComponentLocalStyle && shouldEnableComponentLocalStyle(id) ? new UniAppXComponentLocalStyleCollector(id, runtimeSet) : void 0;
+	if (errors.length === 0) {
+		if (descriptor.template?.ast) traverse(descriptor.template.ast, (node) => {
+			if (node.type !== NodeTypes.ELEMENT) return;
+			const tag = node.tag;
+			for (const prop of node.props) if (prop.type === NodeTypes.ATTRIBUTE) {
+				const { shouldHandle, shouldHandleDefault } = shouldHandleAttribute(tag, prop.name, disabledDefaultTemplateHandler, matchCustomAttribute);
+				if (!shouldHandle) continue;
+				if (shouldHandleDefault && localStyleCollector) updateStaticAttributeWithLocalStyle(ms, prop, localStyleCollector);
+				else updateStaticAttribute(ms, prop);
+				if (shouldHandleDefault) continue;
+			} else if (prop.type === NodeTypes.DIRECTIVE && prop.name === "bind" && prop.arg?.type === NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic) {
+				const attrName = prop.arg.content;
+				const { shouldHandle } = shouldHandleAttribute(tag, attrName, disabledDefaultTemplateHandler, matchCustomAttribute);
+				if (!shouldHandle) continue;
+				if (attrName.toLowerCase() === "class" && localStyleCollector) updateDirectiveExpressionWithLocalStyle(ms, prop, jsHandler, localStyleCollector, runtimeSet);
+				else updateDirectiveExpression(ms, prop, jsHandler, runtimeSet);
+			}
+		});
+		if (descriptor.script) {
+			localStyleCollector?.collectRuntimeClasses(descriptor.script.content);
+			const { code } = jsHandler(descriptor.script.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
+			ms.update(descriptor.script.loc.start.offset, descriptor.script.loc.end.offset, localStyleCollector ? localStyleCollector.rewriteTransformedCode(code) : code);
+		}
+		if (descriptor.scriptSetup) {
+			localStyleCollector?.collectRuntimeClasses(descriptor.scriptSetup.content);
+			const { code } = jsHandler(descriptor.scriptSetup.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
+			ms.update(descriptor.scriptSetup.loc.start.offset, descriptor.scriptSetup.loc.end.offset, localStyleCollector ? localStyleCollector.rewriteTransformedCode(code) : code);
+		}
+		if (localStyleCollector?.hasStyles()) ms.append(`\n${localStyleCollector.toStyleBlock()}`);
+	}
+	const result = {
+		code: ms.toString(),
+		map: null
+	};
+	Object.defineProperty(result, "map", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			return ms.generateMap();
+		}
+	});
+	return result;
+}
+//#endregion
+export { transformUVue };

package/dist/{utils-D7Ygohep.js → utils-nta4tfFs.js}

@@ -1,4 +1,4 @@
-const require_chunk = require("./chunk-C5U5_Hdc.js");
+const require_chunk = require("./chunk-D6vf50IK.js");
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
 require("@weapp-tailwindcss/shared");

package/dist/{v3-engine-CmIF_gsq.js → v3-engine-CBahpuIg.js}

@@ -1,5 +1,5 @@
-const require_chunk = require("./chunk-C5U5_Hdc.js");
-const require_auto = require("./auto-dPpsm6FB.js");
+const require_chunk = require("./chunk-D6vf50IK.js");
+const require_auto = require("./auto-BZ4n4Icc.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_module = require("node:module");