boss-css 0.0.1 → 0.0.3

package/dist/compile/classname.cjs

@@ -0,0 +1,366 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let _swc_core = require("@swc/core");
+
+//#region src/compile/classname.ts
+const tokenPrefix = "$$.token.";
+const rewriteClassNameTokens = (input) => {
+	if (!input.includes(tokenPrefix) && !input.includes("{")) return input;
+	return splitSelectors(input).flatMap((selector) => rewriteSelector(selector, { expandSingleGroup: false })).join(" ");
+};
+const rewriteClassNameTokensInText = (source, options = {}) => {
+	return rewriteQuotedSegments(source, ({ value, hasTemplateExpression }) => {
+		if (hasTemplateExpression) return null;
+		return rewriteClassNameTokensWithMap(value, options.mapToken);
+	});
+};
+const rewriteClassNameTokensInSource = (source, options) => {
+	const ext = options.filename.split(".").pop() ?? "";
+	const isTs = ext === "ts" || ext === "tsx";
+	const isJsx = [
+		"jsx",
+		"tsx",
+		"js",
+		"mjs",
+		"cjs"
+	].includes(ext);
+	const classNameProp = options.classNameProp ?? "className";
+	const mapToken = options.mapToken;
+	const parsed = (0, _swc_core.parseSync)(source, {
+		syntax: isTs ? "typescript" : "ecmascript",
+		tsx: isTs && isJsx,
+		jsx: !isTs && isJsx
+	});
+	const visit = (node, context = {}) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			node.forEach((child) => visit(child, context));
+			return;
+		}
+		const current = node;
+		if (current.type === "JSXElement") rewriteClassNameTokensInElement(current, classNameProp, mapToken);
+		if (current.type === "CallExpression") rewriteClassNameTokensInCall(current, mapToken);
+		if (!context.inModuleSpecifier) {
+			if (current.type === "StringLiteral") {
+				const literal = current;
+				updateStringLiteral(literal, rewriteClassNameTokensWithMap(literal.value, mapToken));
+			}
+			if (current.type === "TemplateLiteral" && Array.isArray(current.expressions) && current.expressions.length === 0 && Array.isArray(current.quasis) && current.quasis.length) {
+				const firstQuasi = current.quasis[0];
+				if (firstQuasi) {
+					const rewritten = rewriteClassNameTokensWithMap(firstQuasi.cooked ?? "", mapToken);
+					firstQuasi.cooked = rewritten;
+					firstQuasi.raw = rewritten;
+				}
+			}
+		}
+		for (const key of Object.keys(current)) {
+			const nextContext = (current.type === "ImportDeclaration" || current.type === "ExportAllDeclaration" || current.type === "ExportNamedDeclaration") && key === "source" ? {
+				...context,
+				inModuleSpecifier: true
+			} : context;
+			visit(current[key], nextContext);
+		}
+	};
+	visit(parsed);
+	return (0, _swc_core.printSync)(parsed).code;
+};
+const rewriteClassNameTokensInCall = (expr, mapToken) => {
+	const callee = expr.callee;
+	if (callee.type !== "Identifier" || callee.value !== "$$") return;
+	if (expr.arguments.length !== 1) return;
+	const arg = expr.arguments[0].expression;
+	rewriteStringExpression(arg, mapToken);
+};
+const rewriteStringExpression = (expression, mapToken) => {
+	if (!expression) return;
+	if (expression.type === "StringLiteral") {
+		updateStringLiteral(expression, rewriteClassNameTokensWithMap(expression.value, mapToken));
+		return;
+	}
+	if (expression.type === "TemplateLiteral" && expression.expressions.length === 0 && expression.quasis.length) {
+		const firstQuasi = expression.quasis[0];
+		if (!firstQuasi) return;
+		const rewritten = rewriteClassNameTokensWithMap(firstQuasi.cooked ?? "", mapToken);
+		firstQuasi.cooked = rewritten;
+		firstQuasi.raw = rewritten;
+	}
+};
+const rewriteClassNameTokensInElement = (element, classNameProp = "className", mapToken) => {
+	const attributes = element.opening.attributes;
+	for (const attr of attributes) {
+		if (attr.type !== "JSXAttribute") continue;
+		if (!isClassAttribute(attr, classNameProp)) continue;
+		if (!attr.value) continue;
+		if (attr.value.type === "StringLiteral") {
+			updateStringLiteral(attr.value, rewriteClassNameTokensWithMap(attr.value.value, mapToken));
+			continue;
+		}
+		if (attr.value.type === "JSXExpressionContainer") {
+			const expression = attr.value.expression;
+			rewriteStringExpression(expression, mapToken);
+		}
+	}
+};
+const isClassAttribute = (attr, classNameProp) => {
+	return attr.name.type === "Identifier" && attr.name.value === classNameProp;
+};
+const rewriteSelector = (selector, options) => {
+	const grouped = parseGroupedSelector(selector);
+	if (grouped) {
+		const nextEntries = grouped.entries.map((entry$1) => ({
+			name: entry$1.name,
+			rawValue: rewriteTokenValue(entry$1.rawValue)
+		}));
+		if (nextEntries.length > 1 || options.expandSingleGroup) return [...nextEntries].sort((a, b) => a.name.localeCompare(b.name)).map((entry$1) => `${grouped.prefix}:${entry$1.name}:${entry$1.rawValue}`);
+		const [entry] = nextEntries;
+		return [`${grouped.prefix}:{${entry.name}:${entry.rawValue}}`];
+	}
+	const fragments = splitFragments(selector);
+	if (fragments.length < 2) return [selector];
+	const rawValue = fragments.at(-1) ?? "";
+	const nextValue = rewriteTokenValue(rawValue);
+	if (nextValue === rawValue) return [selector];
+	return [`${fragments.slice(0, -1).join(":")}:${nextValue}`];
+};
+const rewriteClassNameTokensWithMap = (input, mapToken) => {
+	if (!mapToken) return rewriteClassNameTokens(input);
+	const selectors = splitSelectors(input).flatMap((selector) => rewriteSelector(selector, { expandSingleGroup: true }));
+	let didChange = selectors.join(" ") !== input;
+	const mapped = selectors.map((selector) => {
+		if (!mapToken) return selector;
+		const next = mapToken(selector);
+		if (next && next !== selector) {
+			didChange = true;
+			return next;
+		}
+		return selector;
+	});
+	if (!didChange) return input;
+	return mapped.join(" ");
+};
+const rewriteTokenValue = (rawValue) => {
+	if (!rawValue.startsWith(tokenPrefix)) return rawValue;
+	const fragments = rawValue.slice(9).split(".").filter(Boolean);
+	if (fragments.length < 2) return rawValue;
+	return fragments.slice(1).join(".");
+};
+const updateStringLiteral = (literal, nextValue) => {
+	literal.value = nextValue;
+	literal.raw = JSON.stringify(nextValue);
+};
+const splitSelectors = (input) => splitOutside(input, " ");
+const splitFragments = (selector) => splitOutside(selector, ":");
+const splitGroupedEntries = (body) => splitOutside(body, ";");
+const splitGroupedEntry = (entry) => splitOnceOutside(entry, ":");
+const parseGroupedSelector = (selector) => {
+	if (!selector.endsWith("}")) return null;
+	const groupStart = findGroupStart(selector);
+	if (groupStart === -1) return null;
+	const prefix = selector.slice(0, groupStart);
+	const entries = splitGroupedEntries(selector.slice(groupStart + 2, -1)).map((entry) => entry.trim()).filter((entry) => Boolean(entry)).map((entry) => {
+		const parts = splitGroupedEntry(entry);
+		if (!parts) return null;
+		const [name, rawValue] = parts;
+		return {
+			name: name.trim(),
+			rawValue: rawValue.trim()
+		};
+	}).filter((entry) => Boolean(entry));
+	if (!entries.length) return null;
+	return {
+		prefix,
+		entries
+	};
+};
+const splitOutside = (input, delimiter) => {
+	const results = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (const char of input) {
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) {
+			if (current) results.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current) results.push(current);
+	return results;
+};
+const splitOnceOutside = (input, delimiter) => {
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (let i = 0; i < input.length; i += 1) {
+		const char = input[i];
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) return [input.slice(0, i), input.slice(i + 1)];
+	}
+	return null;
+};
+const findGroupStart = (selector) => {
+	let bracketDepth = 0;
+	for (let i = 0; i < selector.length - 1; i += 1) {
+		const char = selector[i];
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (bracketDepth === 0 && selector[i] === ":" && selector[i + 1] === "{") return i;
+	}
+	return -1;
+};
+const stripImportantSuffix = (fragment) => {
+	return fragment && fragment.endsWith("!") ? fragment.slice(0, -1) : fragment;
+};
+const getChildSelector = (fragment) => {
+	if (!fragment || !fragment.startsWith("[") || !fragment.endsWith("]")) return null;
+	return fragment.slice(1, -1);
+};
+const isSingleWordToken = (token) => /^[a-zA-Z]+$/.test(token);
+const isBossSelectorToken = (selector, api) => {
+	if (isSingleWordToken(selector)) return false;
+	if (parseGroupedSelector(selector)) return true;
+	const rawFragments = splitFragments(selector);
+	if (!rawFragments.length) return false;
+	const resolveDescriptor = (fragment) => {
+		if (getChildSelector(fragment)) return api.dictionary.resolve("child");
+		return api.dictionary.resolve(fragment);
+	};
+	const firstDescriptor = resolveDescriptor(stripImportantSuffix(rawFragments[0])).descriptor;
+	if (!firstDescriptor) return false;
+	if (rawFragments.length === 1) return firstDescriptor.single === true;
+	const path = [];
+	for (const [index, fragment] of Object.entries(rawFragments)) {
+		const isLast = rawFragments.length === +index + 1;
+		if (path.length && isLast) continue;
+		const cleanedFragment = stripImportantSuffix(fragment);
+		const childSelector = getChildSelector(cleanedFragment);
+		if (childSelector) path.push("child", childSelector);
+		else path.push(cleanedFragment);
+	}
+	if (!path.length) return false;
+	const lastProp = path.at(-1);
+	const lastDescriptor = lastProp ? resolveDescriptor(lastProp).descriptor : null;
+	return Boolean(lastDescriptor?.isCSSProp);
+};
+const collectBossClassTokensInSource = (source, options) => {
+	const ext = options.filename.split(".").pop() ?? "";
+	const isTs = ext === "ts" || ext === "tsx";
+	const isJsx = [
+		"jsx",
+		"tsx",
+		"js",
+		"mjs",
+		"cjs"
+	].includes(ext);
+	const parsed = (0, _swc_core.parseSync)(source, {
+		syntax: isTs ? "typescript" : "ecmascript",
+		tsx: isTs && isJsx,
+		jsx: !isTs && isJsx
+	});
+	const tokens = /* @__PURE__ */ new Set();
+	const visit = (node, context = {}) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			node.forEach((child) => visit(child, context));
+			return;
+		}
+		const current = node;
+		if (!context.inModuleSpecifier) {
+			if (current.type === "StringLiteral") splitSelectors(current.value).flatMap((selector) => rewriteSelector(selector, { expandSingleGroup: true })).forEach((selector) => {
+				if (isBossSelectorToken(selector, options.api)) tokens.add(selector);
+			});
+			if (current.type === "TemplateLiteral" && Array.isArray(current.expressions) && current.expressions.length === 0 && Array.isArray(current.quasis) && current.quasis.length) {
+				const firstQuasi = current.quasis[0];
+				if (firstQuasi?.cooked != null) splitSelectors(firstQuasi.cooked).flatMap((selector) => rewriteSelector(selector, { expandSingleGroup: true })).forEach((selector) => {
+					if (isBossSelectorToken(selector, options.api)) tokens.add(selector);
+				});
+			}
+		}
+		for (const key of Object.keys(current)) {
+			const nextContext = (current.type === "ImportDeclaration" || current.type === "ExportAllDeclaration" || current.type === "ExportNamedDeclaration") && key === "source" ? {
+				...context,
+				inModuleSpecifier: true
+			} : context;
+			visit(current[key], nextContext);
+		}
+	};
+	visit(parsed);
+	return tokens;
+};
+const collectBossClassTokensInText = (source, options) => {
+	const tokens = /* @__PURE__ */ new Set();
+	rewriteQuotedSegments(source, ({ value, hasTemplateExpression }) => {
+		if (hasTemplateExpression) return null;
+		splitSelectors(value).flatMap((selector) => rewriteSelector(selector, { expandSingleGroup: true })).forEach((selector) => {
+			if (isBossSelectorToken(selector, options.api)) tokens.add(selector);
+		});
+		return null;
+	});
+	return tokens;
+};
+const rewriteQuotedSegments = (input, rewrite) => {
+	let output = "";
+	let index = 0;
+	const length = input.length;
+	while (index < length) {
+		const char = input[index];
+		if (char !== "\"" && char !== "'" && char !== "`") {
+			output += char;
+			index += 1;
+			continue;
+		}
+		const quote = char;
+		const start = index;
+		index += 1;
+		let value = "";
+		let escaped = false;
+		let hasTemplateExpression = false;
+		while (index < length) {
+			const current = input[index];
+			if (escaped) {
+				value += current;
+				escaped = false;
+				index += 1;
+				continue;
+			}
+			if (current === "\\") {
+				value += current;
+				escaped = true;
+				index += 1;
+				continue;
+			}
+			if (quote === "`" && current === "$" && input[index + 1] === "{") hasTemplateExpression = true;
+			if (current === quote) break;
+			value += current;
+			index += 1;
+		}
+		if (index >= length) {
+			output += input.slice(start);
+			break;
+		}
+		const replacement = rewrite({
+			value,
+			quote,
+			hasTemplateExpression
+		});
+		if (replacement === null) output += quote + value + quote;
+		else output += quote + replacement + quote;
+		index += 1;
+	}
+	return output;
+};
+
+//#endregion
+exports.collectBossClassTokensInSource = collectBossClassTokensInSource;
+exports.collectBossClassTokensInText = collectBossClassTokensInText;
+exports.rewriteClassNameTokensInElement = rewriteClassNameTokensInElement;
+exports.rewriteClassNameTokensInSource = rewriteClassNameTokensInSource;
+exports.rewriteClassNameTokensInText = rewriteClassNameTokensInText;
+exports.rewriteClassNameTokensWithMap = rewriteClassNameTokensWithMap;