boss-css 0.0.1 → 0.0.3

package/dist/compile/transform.mjs

@@ -0,0 +1,369 @@
+import { getClassNameProp } from "../shared/framework.mjs";
+import { rewriteClassNameTokensInElement, rewriteClassNameTokensWithMap } from "./classname.mjs";
+import { buildPreparedDefinition, transformJsxElement } from "./jsx.mjs";
+import { extractCustomCssText } from "../shared/customCss.mjs";
+import path from "node:path";
+import { parseSync, printSync } from "@swc/core";
+
+//#region src/compile/transform.ts
+const jsxExtensions = new Set([
+	".jsx",
+	".tsx",
+	".js",
+	".mjs",
+	".cjs"
+]);
+const tsExtensions = new Set([".ts", ".tsx"]);
+const fallbackSpan = {
+	start: 0,
+	end: 0,
+	ctxt: 0
+};
+const ensureSpan = (span) => {
+	if (!span) return fallbackSpan;
+	if (typeof span.ctxt === "number") return span;
+	return {
+		...span,
+		ctxt: 0
+	};
+};
+const createVoidExpression = (span) => {
+	const safeSpan = ensureSpan(span);
+	return {
+		type: "UnaryExpression",
+		span: safeSpan,
+		operator: "void",
+		argument: {
+			type: "NumericLiteral",
+			span: safeSpan,
+			value: 0
+		}
+	};
+};
+async function transformSource(source, options) {
+	const ext = path.extname(options.filename);
+	const isTs = tsExtensions.has(ext);
+	const isJsx = jsxExtensions.has(ext);
+	const parsed = parseSync(source, {
+		syntax: isTs ? "typescript" : "ecmascript",
+		tsx: isTs && isJsx,
+		jsx: !isTs && isJsx
+	});
+	const state = {
+		api: options.api,
+		classNameProp: getClassNameProp(options.api.framework),
+		compile: options.compile,
+		filename: options.filename,
+		classNameMapper: options.classNameMapper ?? null,
+		needsRuntime: false,
+		needsValueHelper: false,
+		needsTokenVarsHelper: false,
+		replacedElements: 0,
+		preparedLocal: new Map(options.preparedLocal ?? []),
+		preparedGlobal: options.preparedGlobal ?? /* @__PURE__ */ new Map(),
+		preparedRuntime: options.preparedRuntime ?? /* @__PURE__ */ new Set(),
+		customCssBlocks: []
+	};
+	const transformed = await transformProgram(parsed, state);
+	normalizeSpans(transformed);
+	if (state.customCssBlocks.length) state.api.css?.syncCustomBlocks?.(state.filename, state.customCssBlocks);
+	return {
+		code: printSync(transformed).code,
+		needsRuntime: state.needsRuntime,
+		needsValueHelper: state.needsValueHelper,
+		replacedElements: state.replacedElements
+	};
+}
+const normalizeSpans = (node) => {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		node.forEach(normalizeSpans);
+		return;
+	}
+	const record = node;
+	if (typeof record.type === "string" && record.span && typeof record.ctxt !== "number") record.ctxt = 0;
+	for (const [key, value] of Object.entries(record)) {
+		if (key === "span" && value && typeof value === "object") {
+			const span = value;
+			if (typeof span.start === "number" && typeof span.end === "number" && typeof span.ctxt !== "number") span.ctxt = 0;
+			continue;
+		}
+		normalizeSpans(value);
+	}
+};
+const transformProgram = async (program, state) => {
+	const transformed = await transformNode(program, state);
+	const needsValueHelper = state.needsValueHelper && !hasValueHelper(transformed);
+	const needsTokenVarsHelper = state.needsTokenVarsHelper && !hasTokenVarsHelper(transformed);
+	if (needsValueHelper || needsTokenVarsHelper) {
+		const helper = createRuntimeHelpersProgram({
+			unit: state.api.unit ?? "px",
+			prefix: state.api.selectorPrefix ?? "",
+			needsValueHelper,
+			needsTokenVarsHelper
+		});
+		if ("body" in transformed) transformed.body = [...helper.body, ...transformed.body];
+	}
+	if (!state.needsRuntime && "body" in transformed) transformed.body = transformed.body.filter((node) => {
+		if (node.type !== "ImportDeclaration") return true;
+		const source = node.source.value;
+		return !isBossImport(source);
+	});
+	return transformed;
+};
+const transformNode = async (node, state, context = {}) => {
+	if (!node || typeof node !== "object") return node;
+	if (Array.isArray(node)) {
+		const mapped = [];
+		for (const child of node) {
+			const next = await transformNode(child, state, context);
+			if (next === null) continue;
+			mapped.push(next);
+		}
+		return mapped;
+	}
+	const current = node;
+	const mapToken = state.classNameMapper ? (token) => state.classNameMapper?.get(token) : void 0;
+	let keepPreparedMarker = false;
+	if (current.type === "ExpressionStatement") {
+		const expression = current.expression;
+		if (expression) {
+			const cssText = extractCustomCssText(expression, state.api);
+			if (cssText != null) {
+				const span = ensureSpan(expression.span);
+				state.customCssBlocks.push({
+					start: span.start,
+					end: span.end,
+					cssText
+				});
+				return null;
+			}
+		}
+	}
+	if (current.type === "CallExpression" || current.type === "TaggedTemplateExpression") {
+		const cssText = extractCustomCssText(current, state.api);
+		if (cssText != null) {
+			const span = ensureSpan(current.span);
+			state.customCssBlocks.push({
+				start: span.start,
+				end: span.end,
+				cssText
+			});
+			return createVoidExpression(span);
+		}
+	}
+	if (isPreparedAssignment(current)) {
+		const prepared = parsePreparedDefinition(current.expression);
+		if (prepared) {
+			state.preparedLocal.set(prepared.name, prepared.definition);
+			if (state.preparedRuntime.has(prepared.name)) {
+				state.needsRuntime = true;
+				keepPreparedMarker = true;
+			} else return null;
+		}
+	}
+	if (isPreparedAssignmentExpression(current)) {
+		const prepared = parsePreparedDefinition(current);
+		if (prepared) {
+			state.preparedLocal.set(prepared.name, prepared.definition);
+			state.needsRuntime = true;
+			keepPreparedMarker = true;
+		}
+	}
+	if (state.classNameMapper && !context.inModuleSpecifier) {
+		if (current.type === "StringLiteral") {
+			const literal = current;
+			const rewritten = rewriteClassNameTokensWithMap(literal.value, mapToken);
+			if (rewritten !== literal.value) {
+				literal.value = rewritten;
+				literal.raw = JSON.stringify(rewritten);
+			}
+		}
+		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 cooked = firstQuasi.cooked ?? "";
+				const rewritten = rewriteClassNameTokensWithMap(cooked, mapToken);
+				if (rewritten !== cooked) {
+					firstQuasi.cooked = rewritten;
+					firstQuasi.raw = rewritten;
+				}
+			}
+		}
+	}
+	const isBossElement = current.type === "JSXElement" && isBossJsxElement(current);
+	const isBossMarkerCall = (() => {
+		if (current.type !== "CallExpression") return false;
+		const call = current;
+		if (call.callee.type !== "MemberExpression") return false;
+		if (call.callee.object?.type !== "Identifier" || call.callee.object.value !== "$$") return false;
+		if (call.callee.property?.type !== "Identifier" || call.callee.property.value !== "$") return false;
+		return true;
+	})();
+	for (const key of Object.keys(current)) {
+		let childContext = context.inJsxChild && current.type !== "JSXElement" ? {
+			...context,
+			inJsxChild: false
+		} : context;
+		if (isBossElement) childContext = {
+			...childContext,
+			inBossElement: true
+		};
+		if (current.type === "JSXElement" && key === "children") childContext = {
+			...childContext,
+			inJsxChild: true
+		};
+		if (keepPreparedMarker) {
+			if (current.type === "ExpressionStatement" && key === "expression") childContext = {
+				...childContext,
+				keepBossMarker: true
+			};
+			if (current.type === "AssignmentExpression" && key === "right") childContext = {
+				...childContext,
+				keepBossMarker: true
+			};
+		}
+		if (isBossMarkerCall && key === "callee") childContext = {
+			...childContext,
+			inBossMarkerCall: true
+		};
+		if (current.type === "JSXAttribute" && key === "value") {
+			const attrName = getJsxAttributeName(current);
+			const isBossProp = Boolean(context.inBossElement && attrName && state.api.dictionary.resolve(attrName).descriptor);
+			childContext = {
+				...childContext,
+				inBossPropValue: isBossProp
+			};
+		}
+		if (current.type === "CallExpression" && key === "arguments") {
+			const callee = current.callee;
+			const args = current.arguments;
+			if (callee.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.value === "$$" && callee.property?.type === "Identifier" && callee.property.value === "$" && args.length === 1 && args[0].expression.type === "ObjectExpression") childContext = {
+				...childContext,
+				inBossPropValue: true
+			};
+		}
+		if ((current.type === "ImportDeclaration" || current.type === "ExportAllDeclaration" || current.type === "ExportNamedDeclaration") && key === "source") childContext = {
+			...childContext,
+			inModuleSpecifier: true
+		};
+		current[key] = await transformNode(current[key], state, childContext);
+	}
+	if (current.type === "JSXElement") {
+		const element = current;
+		rewriteClassNameTokensInElement(element, state.classNameProp, mapToken);
+		return transformJsxElement(element, state, context);
+	}
+	if (current.type === "CallExpression") {
+		const expr = current;
+		const callee = expr.callee;
+		const isBossMarker = callee.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.value === "$$" && callee.property?.type === "Identifier" && callee.property.value === "$";
+		if (isBossMarker && context.keepBossMarker) return current;
+		if (isBossMarker && expr.arguments.length === 1 && expr.arguments[0].expression.type === "ObjectExpression") return expr.arguments[0].expression;
+		if (isBossMarker && expr.arguments.length === 1) {
+			const arg = expr.arguments[0].expression;
+			if (arg.type === "StringLiteral") {
+				const rewritten = rewriteClassNameTokensWithMap(arg.value, mapToken);
+				arg.value = rewritten;
+				arg.raw = JSON.stringify(rewritten);
+			} else if (arg.type === "TemplateLiteral" && arg.expressions.length === 0) {
+				const rewritten = rewriteClassNameTokensWithMap(arg.quasis[0].cooked ?? "", mapToken);
+				arg.quasis[0].cooked = rewritten;
+				arg.quasis[0].raw = rewritten;
+			}
+			return arg;
+		}
+		if (callee.type === "Identifier" && callee.value === "$$") state.needsRuntime = true;
+	}
+	if (current.type === "MemberExpression") {
+		if (context.inBossPropValue) return current;
+		if (context.inBossMarkerCall) return current;
+		const member = current;
+		if (member.object?.type === "Identifier" && member.object.value === "$$") state.needsRuntime = true;
+	}
+	return current;
+};
+const isBossJsxElement = (node) => {
+	const name = node.opening.name;
+	if (name.type === "Identifier" && name.value === "$$") return true;
+	if (name.type === "JSXMemberExpression" && name.object.type === "Identifier" && name.object.value === "$$") return true;
+	return false;
+};
+const getJsxAttributeName = (node) => {
+	if (node.name?.type === "Identifier") return node.name.value;
+	return null;
+};
+const createRuntimeHelpersProgram = ({ unit, prefix, needsValueHelper, needsTokenVarsHelper }) => {
+	const imports = [];
+	const lines = [];
+	if (needsValueHelper) {
+		imports.push("createBossValue");
+		lines.push(`const __bossValue = createBossValue(${JSON.stringify(unit)});`);
+	}
+	if (needsTokenVarsHelper) {
+		imports.push("createBossTokenVars");
+		lines.push(`const __bossTokenVars = createBossTokenVars(${JSON.stringify(unit)}, ${JSON.stringify(prefix)});`);
+	}
+	return parseSync(`import { ${imports.join(", ")} } from "boss-css/compile/runtime";
+${lines.join("\n")}`, { syntax: "ecmascript" });
+};
+const hasValueHelper = (program) => {
+	if (!("body" in program)) return false;
+	return program.body.some((node) => {
+		if (node.type !== "VariableDeclaration") return false;
+		return node.declarations.some((decl) => decl.id.type === "Identifier" && decl.id.value === "__bossValue");
+	});
+};
+const hasTokenVarsHelper = (program) => {
+	if (!("body" in program)) return false;
+	return program.body.some((node) => {
+		if (node.type !== "VariableDeclaration") return false;
+		return node.declarations.some((decl) => decl.id.type === "Identifier" && decl.id.value === "__bossTokenVars");
+	});
+};
+const isBossImport = (source) => {
+	if (source === "boss-css/compile/runtime") return false;
+	return source.includes(".bo$$/server") || source === "boss-css" || source.startsWith("boss-css/") || source === "boss-css/parser/jsx/runtime" || source === "boss-css/runtime" || source.startsWith("boss-css/runtime/") || source.startsWith("@boss-css/");
+};
+const isPreparedAssignmentExpression = (node) => {
+	if (node.type !== "AssignmentExpression") return false;
+	const assignment = node;
+	if (assignment.operator && assignment.operator !== "=") return false;
+	const left = assignment.left;
+	if (!left || left.type !== "MemberExpression") return false;
+	if (left.object?.type !== "Identifier" || left.object.value !== "$$") return false;
+	const property = left.property;
+	if (!property || property.type !== "Identifier") return false;
+	if (!property.value || !/^[A-Z]/.test(property.value)) return false;
+	return Boolean(assignment.right && getPreparedObjectExpression(assignment.right));
+};
+const isPreparedAssignment = (node) => {
+	if (node.type !== "ExpressionStatement") return false;
+	const statement = node;
+	return Boolean(statement.expression && isPreparedAssignmentExpression(statement.expression));
+};
+const parsePreparedDefinition = (expression) => {
+	const assignment = expression;
+	const name = assignment.left?.property?.value;
+	const objectExpression = assignment.right ? getPreparedObjectExpression(assignment.right) : null;
+	if (!name || !objectExpression) return null;
+	const definition = buildPreparedDefinition(objectExpression);
+	if (!definition) return null;
+	return {
+		name,
+		definition
+	};
+};
+const getPreparedObjectExpression = (expression) => {
+	if (expression.type === "CallExpression" && expression.arguments.length === 1) {
+		const callee = expression.callee;
+		if (callee.type === "MemberExpression" && callee.object?.type === "Identifier" && callee.object.value === "$$" && callee.property?.type === "Identifier" && callee.property.value === "$") {
+			const arg = expression.arguments[0].expression;
+			if (arg.type === "ObjectExpression") return arg;
+		}
+	}
+	return null;
+};
+
+//#endregion
+export { transformSource };

package/dist/cx/index.cjs

@@ -0,0 +1,93 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_merge_index = require('../merge/index.cjs');
+let css_variants = require("css-variants");
+
+//#region src/cx/index.ts
+const createBossClassNameResolver = (mergeConfig, resolver = css_variants.cx) => {
+	const merge$1 = require_merge_index.createBossMerge(mergeConfig);
+	return (...inputs) => {
+		return merge$1(resolver(...inputs));
+	};
+};
+const createBossCx = (config = {}) => {
+	const resolve = createBossClassNameResolver(config);
+	return (...inputs) => resolve(...inputs);
+};
+const cx = createBossCx();
+const createBossCv = (mergeConfig = {}) => {
+	return (config) => {
+		const classNameResolver = createBossClassNameResolver(mergeConfig, config.classNameResolver ?? css_variants.cx);
+		return (0, css_variants.cv)({
+			...config,
+			classNameResolver
+		});
+	};
+};
+const cv = createBossCv();
+const createBossScv = (mergeConfig = {}) => {
+	return (config) => {
+		const classNameResolver = createBossClassNameResolver(mergeConfig, config.classNameResolver ?? css_variants.cx);
+		return (0, css_variants.scv)({
+			...config,
+			classNameResolver
+		});
+	};
+};
+const scv = createBossScv();
+const resolveVariantProps = (defaults, props, ignoredKeys) => {
+	const resolved = { ...defaults ?? {} };
+	if (!props) return resolved;
+	for (const [key, value] of Object.entries(props)) {
+		if (value === void 0 || ignoredKeys.has(key)) continue;
+		resolved[key] = value;
+	}
+	return resolved;
+};
+const createBossSv = () => {
+	return (config) => {
+		const { base, variants, compoundVariants, defaultVariants } = config;
+		if (!variants) return (props) => {
+			const parts = [base, props?.style].filter(Boolean);
+			return parts.length ? require_merge_index.merge(...parts) : {};
+		};
+		return (props) => {
+			const resolvedProps = resolveVariantProps(defaultVariants, props, new Set(["style"]));
+			const parts = [];
+			if (base) parts.push(base);
+			for (const [key, value] of Object.entries(resolvedProps)) {
+				const variant = variants[key]?.[value];
+				if (variant) parts.push(variant);
+			}
+			if (compoundVariants) for (const compound of compoundVariants) {
+				let matches = true;
+				for (const [key, value] of Object.entries(compound)) {
+					if (key === "style") continue;
+					const resolvedValue = resolvedProps[key];
+					if (Array.isArray(value)) {
+						if (!value.includes(resolvedValue)) {
+							matches = false;
+							break;
+						}
+					} else if (value !== resolvedValue) {
+						matches = false;
+						break;
+					}
+				}
+				if (matches && compound.style) parts.push(compound.style);
+			}
+			if (props?.style) parts.push(props.style);
+			return parts.length ? require_merge_index.merge(...parts) : {};
+		};
+	};
+};
+const sv = createBossSv();
+
+//#endregion
+exports.createBossCv = createBossCv;
+exports.createBossCx = createBossCx;
+exports.createBossScv = createBossScv;
+exports.createBossSv = createBossSv;
+exports.cv = cv;
+exports.cx = cx;
+exports.scv = scv;
+exports.sv = sv;

package/dist/cx/index.mjs

@@ -0,0 +1,85 @@
+import { createBossMerge, merge } from "../merge/index.mjs";
+import { cv as cv$1, cx as cx$1, scv as scv$1 } from "css-variants";
+
+//#region src/cx/index.ts
+const createBossClassNameResolver = (mergeConfig, resolver = cx$1) => {
+	const merge$1 = createBossMerge(mergeConfig);
+	return (...inputs) => {
+		return merge$1(resolver(...inputs));
+	};
+};
+const createBossCx = (config = {}) => {
+	const resolve = createBossClassNameResolver(config);
+	return (...inputs) => resolve(...inputs);
+};
+const cx = createBossCx();
+const createBossCv = (mergeConfig = {}) => {
+	return (config) => {
+		const classNameResolver = createBossClassNameResolver(mergeConfig, config.classNameResolver ?? cx$1);
+		return cv$1({
+			...config,
+			classNameResolver
+		});
+	};
+};
+const cv = createBossCv();
+const createBossScv = (mergeConfig = {}) => {
+	return (config) => {
+		const classNameResolver = createBossClassNameResolver(mergeConfig, config.classNameResolver ?? cx$1);
+		return scv$1({
+			...config,
+			classNameResolver
+		});
+	};
+};
+const scv = createBossScv();
+const resolveVariantProps = (defaults, props, ignoredKeys) => {
+	const resolved = { ...defaults ?? {} };
+	if (!props) return resolved;
+	for (const [key, value] of Object.entries(props)) {
+		if (value === void 0 || ignoredKeys.has(key)) continue;
+		resolved[key] = value;
+	}
+	return resolved;
+};
+const createBossSv = () => {
+	return (config) => {
+		const { base, variants, compoundVariants, defaultVariants } = config;
+		if (!variants) return (props) => {
+			const parts = [base, props?.style].filter(Boolean);
+			return parts.length ? merge(...parts) : {};
+		};
+		return (props) => {
+			const resolvedProps = resolveVariantProps(defaultVariants, props, new Set(["style"]));
+			const parts = [];
+			if (base) parts.push(base);
+			for (const [key, value] of Object.entries(resolvedProps)) {
+				const variant = variants[key]?.[value];
+				if (variant) parts.push(variant);
+			}
+			if (compoundVariants) for (const compound of compoundVariants) {
+				let matches = true;
+				for (const [key, value] of Object.entries(compound)) {
+					if (key === "style") continue;
+					const resolvedValue = resolvedProps[key];
+					if (Array.isArray(value)) {
+						if (!value.includes(resolvedValue)) {
+							matches = false;
+							break;
+						}
+					} else if (value !== resolvedValue) {
+						matches = false;
+						break;
+					}
+				}
+				if (matches && compound.style) parts.push(compound.style);
+			}
+			if (props?.style) parts.push(props.style);
+			return parts.length ? merge(...parts) : {};
+		};
+	};
+};
+const sv = createBossSv();
+
+//#endregion
+export { createBossCv, createBossCx, createBossScv, createBossSv, cv, cx, scv, sv };