@typestyles/migrate 0.5.1 → 0.5.3

package/dist/migrate-DFON1MgM.js

@@ -0,0 +1,686 @@
+#!/usr/bin/env node
+import { parse } from "@babel/parser";
+import generate from "@babel/generator";
+import traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import postcss from "postcss";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, relative, resolve } from "node:path";
+import { createPatch } from "diff";
+import fg from "fast-glob";
+import picomatch from "picomatch";
+//#region src/css.ts
+function camelCaseProperty$1(property) {
+	return property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function toValueNode(value, varReplacements) {
+	const trimmed = value.trim();
+	if (varReplacements?.has(trimmed)) return varReplacements.get(trimmed);
+	if (/^-?\d+(\.\d+)?$/.test(trimmed)) return t.numericLiteral(Number(trimmed));
+	return t.stringLiteral(trimmed);
+}
+function toKeyNode$1(key) {
+	if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) return t.identifier(key);
+	return t.stringLiteral(key);
+}
+function nodesToObject(nodes, warnings, varReplacements) {
+	const properties = [];
+	for (const node of nodes ?? []) {
+		if (node.type === "decl") {
+			const normalized = node.prop.startsWith("--") ? node.prop : camelCaseProperty$1(node.prop);
+			properties.push(t.objectProperty(toKeyNode$1(normalized), toValueNode(node.value, varReplacements)));
+			continue;
+		}
+		if (node.type === "rule") {
+			const nested = nodesToObject(node.nodes, warnings, varReplacements);
+			properties.push(t.objectProperty(t.stringLiteral(node.selector.trim()), nested));
+			continue;
+		}
+		if (node.type === "atrule") {
+			const nested = nodesToObject(node.nodes, warnings, varReplacements);
+			const atRuleKey = `@${node.name}${node.params ? ` ${node.params}` : ""}`;
+			properties.push(t.objectProperty(t.stringLiteral(atRuleKey), nested));
+			continue;
+		}
+		warnings.push({ message: `Unsupported CSS node "${node.type}" skipped.` });
+	}
+	return t.objectExpression(properties);
+}
+function cssToObjectExpression(cssText, warnings, varReplacements) {
+	try {
+		return nodesToObject(postcss.parse(cssText).nodes, warnings, varReplacements);
+	} catch (error) {
+		warnings.push({ message: `Could not parse CSS template literal: ${error.message}` });
+		return null;
+	}
+}
+//#endregion
+//#region src/interpolations.ts
+const PLACEHOLDER_PREFIX = "__ts_migrate_var_";
+function camelCaseProperty(property) {
+	return property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function placeholderToken(index) {
+	return `${PLACEHOLDER_PREFIX}${index}__`;
+}
+function extractSuffixFromQuasi(quasiText) {
+	return quasiText.match(/^([^;\n]*)/)?.[1] ?? "";
+}
+function literalToCssValue(node) {
+	if (t.isStringLiteral(node)) return node.value;
+	if (t.isNumericLiteral(node)) return String(node.value);
+	return null;
+}
+function unwrapExpression(expression) {
+	if (t.isParenthesizedExpression(expression)) return unwrapExpression(expression.expression);
+	return expression;
+}
+function extractCssPropertyBeforeInterpolation(quasiText) {
+	return quasiText.match(/([a-zA-Z-]+)\s*:\s*$/)?.[1] ?? null;
+}
+function stripTrailingPropertyDeclaration(quasiText) {
+	return quasiText.replace(/[a-zA-Z-]+\s*:\s*$/, "");
+}
+function stripLeadingDeclarationRemainder(quasiText) {
+	const semiIdx = quasiText.indexOf(";");
+	if (semiIdx === -1) return quasiText;
+	return quasiText.slice(semiIdx + 1).trimStart();
+}
+function parsePropInterpolation(expression) {
+	if (!t.isArrowFunctionExpression(expression)) return null;
+	const param = expression.params[0];
+	if (!param) return null;
+	const body = unwrapExpression(expression.body);
+	if (!t.isExpression(body)) return null;
+	if (t.isIdentifier(param)) {
+		if (t.isMemberExpression(body) && !body.computed && t.isIdentifier(body.object, { name: param.name }) && t.isIdentifier(body.property)) return { propName: body.property.name };
+		return null;
+	}
+	if (t.isObjectPattern(param) && t.isIdentifier(body)) {
+		const propName = body.name;
+		if (!param.properties.some((property) => {
+			if (!t.isObjectProperty(property)) return false;
+			return (t.isIdentifier(property.key) ? property.key.name : t.isStringLiteral(property.key) ? property.key.value : null) === propName;
+		})) return null;
+		return { propName };
+	}
+	return null;
+}
+function parseBooleanTernaryInterpolation(expression) {
+	if (!t.isArrowFunctionExpression(expression)) return null;
+	const param = expression.params[0];
+	if (!t.isIdentifier(param)) return null;
+	const body = unwrapExpression(expression.body);
+	if (!t.isConditionalExpression(body)) return null;
+	if (!t.isMemberExpression(body.test) || body.test.computed || !t.isIdentifier(body.test.object, { name: param.name }) || !t.isIdentifier(body.test.property)) return null;
+	const trueValue = literalToCssValue(body.consequent);
+	const falseValue = literalToCssValue(body.alternate);
+	if (trueValue === null || falseValue === null) return null;
+	return {
+		propName: body.test.property.name,
+		trueValue,
+		falseValue
+	};
+}
+function parseTemplateInterpolations(template) {
+	const interpolations = [];
+	for (let i = 0; i < template.expressions.length; i++) {
+		const expression = template.expressions[i];
+		if (!t.isExpression(expression)) return null;
+		const parsed = parsePropInterpolation(expression);
+		if (!parsed) return null;
+		const followingQuasi = template.quasis[i + 1]?.value.cooked ?? "";
+		interpolations.push({
+			index: i,
+			propName: parsed.propName,
+			suffix: extractSuffixFromQuasi(followingQuasi)
+		});
+	}
+	return interpolations;
+}
+function parseBooleanTemplateInterpolations(template) {
+	const interpolations = [];
+	for (let i = 0; i < template.expressions.length; i++) {
+		const expression = template.expressions[i];
+		if (!t.isExpression(expression)) return null;
+		const parsed = parseBooleanTernaryInterpolation(expression);
+		if (!parsed) return null;
+		const cssProperty = extractCssPropertyBeforeInterpolation(template.quasis[i]?.value.cooked ?? "");
+		if (!cssProperty) return null;
+		interpolations.push({
+			index: i,
+			propName: parsed.propName,
+			trueValue: parsed.trueValue,
+			falseValue: parsed.falseValue,
+			cssProperty: camelCaseProperty(cssProperty)
+		});
+	}
+	return interpolations;
+}
+function reconstructInterpolatedCss(template, interpolations) {
+	let result = "";
+	for (let i = 0; i < template.quasis.length; i++) {
+		let quasiText = template.quasis[i].value.cooked ?? "";
+		if (i > 0) {
+			const interpolation = interpolations[i - 1];
+			if (interpolation?.suffix && quasiText.startsWith(interpolation.suffix)) quasiText = quasiText.slice(interpolation.suffix.length);
+		}
+		result += quasiText;
+		if (i < interpolations.length) result += placeholderToken(interpolations[i].index);
+	}
+	return result;
+}
+function reconstructStaticCssWithoutVariants(template, booleanInterpolations) {
+	const skipIndices = new Set(booleanInterpolations.map((interpolation) => interpolation.index));
+	let result = "";
+	for (let i = 0; i < template.quasis.length; i++) {
+		let quasiText = template.quasis[i].value.cooked ?? "";
+		if (skipIndices.has(i)) quasiText = stripTrailingPropertyDeclaration(quasiText);
+		if (i > 0 && skipIndices.has(i - 1)) quasiText = stripLeadingDeclarationRemainder(quasiText);
+		result += quasiText;
+	}
+	return result.trim();
+}
+function toVarDebugName(componentName, propName) {
+	return `${componentName}${propName.charAt(0).toUpperCase()}${propName.slice(1)}`;
+}
+function toComponentConstName(componentName) {
+	if (!componentName) return componentName;
+	return componentName.charAt(0).toLowerCase() + componentName.slice(1);
+}
+//#endregion
+//#region src/variants.ts
+function toCssValueNode(value) {
+	if (/^-?\d+(\.\d+)?$/.test(value.trim())) return t.numericLiteral(Number(value));
+	return t.stringLiteral(value);
+}
+function toKeyNode(key) {
+	if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) return t.identifier(key);
+	return t.stringLiteral(key);
+}
+function buildVariantStyles(properties) {
+	return t.objectExpression(Object.entries(properties).map(([key, value]) => t.objectProperty(toKeyNode(key), toCssValueNode(value))));
+}
+function buildVariantRecipeInput(name, baseObject, booleanInterpolations) {
+	const variantGroups = new Map();
+	for (const interpolation of booleanInterpolations) {
+		const group = variantGroups.get(interpolation.propName) ?? {
+			true: {},
+			false: {}
+		};
+		group.true[interpolation.cssProperty] = interpolation.trueValue;
+		group.false[interpolation.cssProperty] = interpolation.falseValue;
+		variantGroups.set(interpolation.propName, group);
+	}
+	const variantsProperties = [...variantGroups.entries()].map(([propName, values]) => t.objectProperty(t.identifier(propName), t.objectExpression([t.objectProperty(t.identifier("true"), buildVariantStyles(values.true)), t.objectProperty(t.identifier("false"), buildVariantStyles(values.false))])));
+	const axisProperties = [...variantGroups.keys()].map((propName) => t.objectProperty(t.identifier(propName), t.callExpression(t.memberExpression(t.identifier("variant"), t.identifier("boolean")), [t.objectExpression([t.objectProperty(t.identifier("default"), t.booleanLiteral(false))])])));
+	return t.objectExpression([
+		t.objectProperty(t.identifier("name"), t.stringLiteral(name)),
+		t.objectProperty(t.identifier("variants"), t.objectExpression(axisProperties)),
+		t.objectProperty(t.identifier("styles"), t.objectExpression([t.objectProperty(t.identifier("base"), baseObject), t.objectProperty(t.identifier("variants"), t.objectExpression(variantsProperties))]))
+	]);
+}
+//#endregion
+//#region src/transform.ts
+function toKebabCase(input) {
+	return input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+function memberExpressionToJsxName(expression) {
+	if (t.isIdentifier(expression)) return t.jsxIdentifier(expression.name);
+	if (t.isMemberExpression(expression) && !expression.computed) {
+		const left = memberExpressionToJsxName(expression.object);
+		const right = t.isIdentifier(expression.property) ? t.jsxIdentifier(expression.property.name) : null;
+		if (!left || !right) return null;
+		return t.jsxMemberExpression(left, right);
+	}
+	return null;
+}
+function parseStyledTarget(tag, styledNames) {
+	if (t.isMemberExpression(tag) && t.isIdentifier(tag.object) && styledNames.has(tag.object.name) && t.isIdentifier(tag.property)) return {
+		kind: "intrinsic",
+		jsxName: t.jsxIdentifier(tag.property.name)
+	};
+	if (t.isCallExpression(tag) && t.isIdentifier(tag.callee) && styledNames.has(tag.callee.name)) {
+		const firstArg = tag.arguments[0];
+		if (!firstArg || !t.isExpression(firstArg)) return null;
+		const jsxName = memberExpressionToJsxName(firstArg);
+		if (!jsxName) return null;
+		return {
+			kind: "component",
+			jsxName
+		};
+	}
+	return null;
+}
+function addWarning(warnings, message, nodeName) {
+	warnings.push({
+		message,
+		nodeName
+	});
+}
+function createMergedClassExpression(existing, classNameExpression) {
+	return t.callExpression(t.memberExpression(t.callExpression(t.memberExpression(t.arrayExpression([existing, classNameExpression]), t.identifier("filter")), [t.identifier("Boolean")]), t.identifier("join")), [t.stringLiteral(" ")]);
+}
+function updateClassNameAttribute(openingElement, classNameExpression) {
+	const existingAttr = openingElement.attributes.find((attribute) => t.isJSXAttribute(attribute) && t.isJSXIdentifier(attribute.name, { name: "className" }));
+	if (!existingAttr) {
+		openingElement.attributes.push(t.jsxAttribute(t.jsxIdentifier("className"), t.jsxExpressionContainer(classNameExpression)));
+		return;
+	}
+	if (!existingAttr.value) {
+		existingAttr.value = t.jsxExpressionContainer(classNameExpression);
+		return;
+	}
+	if (t.isStringLiteral(existingAttr.value)) {
+		existingAttr.value = t.jsxExpressionContainer(createMergedClassExpression(t.stringLiteral(existingAttr.value.value), classNameExpression));
+		return;
+	}
+	if (t.isJSXExpressionContainer(existingAttr.value)) existingAttr.value = t.jsxExpressionContainer(createMergedClassExpression(existingAttr.value.expression, classNameExpression));
+}
+function hasLocalBinding(ast, name) {
+	for (const statement of ast.program.body) {
+		if (!t.isVariableDeclaration(statement)) continue;
+		for (const declarator of statement.declarations) {
+			if (t.isIdentifier(declarator.id) && declarator.id.name === name) return true;
+			if (t.isObjectPattern(declarator.id)) {
+				for (const prop of declarator.id.properties) if (t.isObjectProperty(prop) && t.isIdentifier(prop.value) && prop.value.name === name) return true;
+			}
+		}
+	}
+	return false;
+}
+function ensureTypestylesRuntime(ast, needs) {
+	const requiredSpecifiers = new Set(["createTypeStyles"]);
+	if (needs.recipe) requiredSpecifiers.add("variant");
+	if (needs.vars) {
+		requiredSpecifiers.add("createVar");
+		requiredSpecifiers.add("assignVars");
+	}
+	let typestylesImport = null;
+	let lastImportIndex = -1;
+	for (let i = 0; i < ast.program.body.length; i++) {
+		const statement = ast.program.body[i];
+		if (t.isImportDeclaration(statement)) {
+			lastImportIndex = i;
+			if (statement.source.value === "typestyles" && typestylesImport == null) typestylesImport = statement;
+		}
+	}
+	const buildSpecifiers = (names) => [...names].map((name) => t.importSpecifier(t.identifier(name), t.identifier(name)));
+	if (!typestylesImport) {
+		ast.program.body.unshift(t.importDeclaration(buildSpecifiers(requiredSpecifiers), t.stringLiteral("typestyles")));
+		lastImportIndex = 0;
+	} else for (const name of requiredSpecifiers) if (!typestylesImport.specifiers.some((specifier) => t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported, { name }) && t.isIdentifier(specifier.local, { name }))) typestylesImport.specifiers.push(t.importSpecifier(t.identifier(name), t.identifier(name)));
+	const destructureProps = [];
+	if (needs.style && !hasLocalBinding(ast, "style")) destructureProps.push(t.objectProperty(t.identifier("style"), t.identifier("style"), false, true));
+	if (needs.recipe && !hasLocalBinding(ast, "recipe")) destructureProps.push(t.objectProperty(t.identifier("recipe"), t.identifier("recipe"), false, true));
+	if (destructureProps.length === 0) return;
+	const factoryDecl = t.variableDeclaration("const", [t.variableDeclarator(t.objectPattern(destructureProps), t.callExpression(t.identifier("createTypeStyles"), []))]);
+	ast.program.body.splice(lastImportIndex + 1, 0, factoryDecl);
+}
+function cleanupUnusedImports(ast) {
+	traverse(ast, {
+		Program(path) {
+			path.scope.crawl();
+		},
+		ImportDeclaration(path) {
+			const unusedLocals = path.node.specifiers.filter((specifier) => {
+				if (path.node.source.value === "typestyles" && t.isImportSpecifier(specifier) && (specifier.local.name === "createTypeStyles" || specifier.local.name === "createVar" || specifier.local.name === "assignVars")) return false;
+				const local = specifier.local.name;
+				const binding = path.scope.getBinding(local);
+				return !binding || binding.referencePaths.length === 0;
+			});
+			if (unusedLocals.length === 0) return;
+			path.node.specifiers = path.node.specifiers.filter((specifier) => !unusedLocals.includes(specifier));
+			if (path.node.specifiers.length === 0) path.remove();
+		}
+	});
+}
+function createAssignVarValue(propExpression, suffix) {
+	if (!suffix) return propExpression;
+	if (t.isStringLiteral(propExpression)) return t.stringLiteral(`${propExpression.value}${suffix}`);
+	return t.binaryExpression("+", propExpression, t.stringLiteral(suffix));
+}
+function buildAssignVarsCall(propVars, propValues) {
+	const properties = propVars.filter((binding) => propValues.has(binding.propName)).map((binding) => {
+		const propExpression = propValues.get(binding.propName);
+		return t.objectProperty(t.identifier(binding.varConstName), createAssignVarValue(propExpression, binding.suffix), true);
+	});
+	return t.callExpression(t.identifier("assignVars"), [t.objectExpression(properties)]);
+}
+function mergeStyleExpressions(existing, assignVarsCall) {
+	return t.objectExpression([t.spreadElement(existing), t.spreadElement(assignVarsCall)]);
+}
+function updateStyleAttribute(openingElement, assignVarsCall) {
+	const existingAttr = openingElement.attributes.find((attribute) => t.isJSXAttribute(attribute) && t.isJSXIdentifier(attribute.name, { name: "style" }));
+	if (!existingAttr) {
+		openingElement.attributes.push(t.jsxAttribute(t.jsxIdentifier("style"), t.jsxExpressionContainer(assignVarsCall)));
+		return;
+	}
+	if (!existingAttr.value) {
+		existingAttr.value = t.jsxExpressionContainer(assignVarsCall);
+		return;
+	}
+	if (t.isJSXExpressionContainer(existingAttr.value)) existingAttr.value = t.jsxExpressionContainer(mergeStyleExpressions(existingAttr.value.expression, assignVarsCall));
+}
+function collectPropValuesFromJsx(openingElement, propNames) {
+	const values = new Map();
+	for (const attribute of openingElement.attributes) {
+		if (!t.isJSXAttribute(attribute) || !t.isJSXIdentifier(attribute.name)) continue;
+		if (!propNames.has(attribute.name.name)) continue;
+		if (!attribute.value) {
+			values.set(attribute.name.name, t.booleanLiteral(true));
+			continue;
+		}
+		if (t.isStringLiteral(attribute.value)) {
+			values.set(attribute.name.name, t.stringLiteral(attribute.value.value));
+			continue;
+		}
+		if (t.isJSXExpressionContainer(attribute.value)) values.set(attribute.name.name, attribute.value.expression);
+	}
+	return values;
+}
+function removeStyledProps(openingElement, propNames) {
+	openingElement.attributes = openingElement.attributes.filter((attribute) => {
+		if (!t.isJSXAttribute(attribute) || !t.isJSXIdentifier(attribute.name)) return true;
+		return !propNames.has(attribute.name.name);
+	});
+}
+function buildComponentClassNameExpression(componentConstName, variantProps, propValues) {
+	const properties = variantProps.filter((propName) => propValues.has(propName)).map((propName) => t.objectProperty(t.identifier(propName), propValues.get(propName)));
+	const call = properties.length === 0 ? t.callExpression(t.identifier(componentConstName), []) : t.callExpression(t.identifier(componentConstName), [t.objectExpression(properties)]);
+	return t.memberExpression(call, t.identifier("className"));
+}
+function migrateBooleanVariantTemplate(path, variableName, template, styledTarget, warnings, styledTransforms) {
+	const booleanInterpolations = parseBooleanTemplateInterpolations(template);
+	if (!booleanInterpolations) return false;
+	const baseObject = cssToObjectExpression(reconstructStaticCssWithoutVariants(template, booleanInterpolations), warnings);
+	if (!baseObject) {
+		addWarning(warnings, "Skipped because CSS could not be parsed.", variableName);
+		return false;
+	}
+	const componentConstName = path.scope.generateUidIdentifier(toComponentConstName(variableName)).name;
+	const recipeInput = buildVariantRecipeInput(toKebabCase(variableName), baseObject, booleanInterpolations);
+	const variantProps = [...new Set(booleanInterpolations.map((interpolation) => interpolation.propName))];
+	const declaration = path.parentPath;
+	if (!declaration.isVariableDeclaration()) return false;
+	declaration.node.declarations = [t.variableDeclarator(t.identifier(componentConstName), t.callExpression(t.identifier("recipe"), [recipeInput]))];
+	styledTransforms.set(variableName, {
+		originalName: variableName,
+		mode: "component",
+		classConstName: componentConstName,
+		target: styledTarget,
+		propVars: [],
+		variantProps
+	});
+	return true;
+}
+function migrateInterpolatedTemplate(path, variableName, template, styledTarget, warnings, styledTransforms) {
+	const interpolations = parseTemplateInterpolations(template);
+	if (!interpolations) {
+		addWarning(warnings, "Skipped template literal with unsupported interpolations. Only prop-based patterns like `${props => props.color}` are migrated.", variableName);
+		return false;
+	}
+	const cssText = reconstructInterpolatedCss(template, interpolations);
+	const propVars = interpolations.map((interpolation) => ({
+		propName: interpolation.propName,
+		varConstName: path.scope.generateUidIdentifier(`${variableName}${interpolation.propName.charAt(0).toUpperCase()}${interpolation.propName.slice(1)}Var`).name,
+		suffix: interpolation.suffix
+	}));
+	const varReplacements = new Map();
+	for (let i = 0; i < interpolations.length; i++) varReplacements.set(placeholderToken(interpolations[i].index), t.identifier(propVars[i].varConstName));
+	const objectExpression = cssToObjectExpression(cssText, warnings, varReplacements);
+	if (!objectExpression) {
+		addWarning(warnings, "Skipped because CSS could not be parsed.", variableName);
+		return false;
+	}
+	const classConstName = path.scope.generateUidIdentifier(`${variableName}Class`).name;
+	const varDeclarators = propVars.map((propVar) => t.variableDeclarator(t.identifier(propVar.varConstName), t.callExpression(t.identifier("createVar"), [t.stringLiteral(toVarDebugName(variableName, propVar.propName))])));
+	const declaration = path.parentPath;
+	if (!declaration.isVariableDeclaration()) return false;
+	declaration.node.declarations = [...varDeclarators, t.variableDeclarator(t.identifier(classConstName), t.callExpression(t.identifier("style"), [t.stringLiteral(toKebabCase(variableName)), objectExpression]))];
+	styledTransforms.set(variableName, {
+		originalName: variableName,
+		mode: "class",
+		classConstName,
+		target: styledTarget,
+		propVars,
+		variantProps: []
+	});
+	return true;
+}
+function isOnlyJsxReferences(binding) {
+	return binding.referencePaths.every((referencePath) => {
+		const parent = referencePath.parentPath;
+		if (!parent) return false;
+		return parent.isJSXOpeningElement() && parent.get("name") === referencePath || parent.isJSXClosingElement() && parent.get("name") === referencePath;
+	});
+}
+function migrateSource(filePath, source) {
+	const warnings = [];
+	let changed = false;
+	const ast = parse(source, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const styledNames = new Set();
+	const cssTagNames = new Set();
+	const styledTransforms = new Map();
+	let needsVars = false;
+	let needsStyle = false;
+	let needsRecipe = false;
+	traverse(ast, { ImportDeclaration(path) {
+		if (path.node.source.value === "styled-components" || path.node.source.value === "@emotion/styled") for (const specifier of path.node.specifiers) {
+			if (t.isImportDefaultSpecifier(specifier)) styledNames.add(specifier.local.name);
+			if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported, { name: "css" })) cssTagNames.add(specifier.local.name);
+		}
+		if (path.node.source.value === "@emotion/react" || path.node.source.value === "@emotion/css") {
+			for (const specifier of path.node.specifiers) if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported, { name: "css" })) cssTagNames.add(specifier.local.name);
+		}
+	} });
+	traverse(ast, { VariableDeclarator(path) {
+		if (!t.isIdentifier(path.node.id)) return;
+		if (!t.isTaggedTemplateExpression(path.node.init)) return;
+		const variableName = path.node.id.name;
+		const binding = path.scope.getBinding(variableName);
+		if (!binding) return;
+		const template = path.node.init.quasi;
+		const hasInterpolations = template.expressions.length > 0;
+		const styledTarget = parseStyledTarget(path.node.init.tag, styledNames);
+		if (hasInterpolations) {
+			if (!styledTarget) {
+				addWarning(warnings, "Skipped template literal with interpolations. Only styled-components prop patterns are migrated.", variableName);
+				return;
+			}
+			const declaration = path.parentPath;
+			if (declaration.parentPath?.isExportNamedDeclaration() || declaration.parentPath?.isExportDefaultDeclaration()) {
+				addWarning(warnings, "Skipped exported styled component to avoid changing external API shape.", variableName);
+				return;
+			}
+			if (!isOnlyJsxReferences(binding)) {
+				addWarning(warnings, "Skipped styled component with non-JSX references.", variableName);
+				return;
+			}
+			if (migrateBooleanVariantTemplate(path, variableName, template, styledTarget, warnings, styledTransforms)) {
+				needsRecipe = true;
+				changed = true;
+				return;
+			}
+			if (migrateInterpolatedTemplate(path, variableName, template, styledTarget, warnings, styledTransforms)) {
+				needsVars = true;
+				needsStyle = true;
+				changed = true;
+			}
+			return;
+		}
+		const objectExpression = cssToObjectExpression(template.quasis.map((quasi) => quasi.value.cooked ?? "").join(""), warnings);
+		if (!objectExpression) {
+			addWarning(warnings, "Skipped because CSS could not be parsed.", variableName);
+			return;
+		}
+		if (styledTarget) {
+			const declaration = path.parentPath;
+			if (declaration.parentPath?.isExportNamedDeclaration() || declaration.parentPath?.isExportDefaultDeclaration()) {
+				addWarning(warnings, "Skipped exported styled component to avoid changing external API shape.", variableName);
+				return;
+			}
+			if (!isOnlyJsxReferences(binding)) {
+				addWarning(warnings, "Skipped styled component with non-JSX references.", variableName);
+				return;
+			}
+			const classConstName = path.scope.generateUidIdentifier(`${variableName}Class`).name;
+			path.node.id = t.identifier(classConstName);
+			path.node.init = t.callExpression(t.identifier("style"), [t.stringLiteral(toKebabCase(variableName)), objectExpression]);
+			styledTransforms.set(variableName, {
+				originalName: variableName,
+				mode: "class",
+				classConstName,
+				target: styledTarget,
+				propVars: [],
+				variantProps: []
+			});
+			needsStyle = true;
+			changed = true;
+			return;
+		}
+		if (t.isIdentifier(path.node.init.tag) && cssTagNames.has(path.node.init.tag.name)) {
+			path.node.init = t.callExpression(t.identifier("style"), [t.stringLiteral(toKebabCase(variableName)), objectExpression]);
+			needsStyle = true;
+			changed = true;
+		}
+	} });
+	if (styledTransforms.size > 0) traverse(ast, { JSXElement(path) {
+		const openingName = path.node.openingElement.name;
+		if (!t.isJSXIdentifier(openingName)) return;
+		const transform = styledTransforms.get(openingName.name);
+		if (!transform) return;
+		path.node.openingElement.name = transform.target.jsxName;
+		if (path.node.closingElement) path.node.closingElement.name = transform.target.jsxName;
+		const classNameExpression = transform.mode === "component" ? buildComponentClassNameExpression(transform.classConstName, transform.variantProps, collectPropValuesFromJsx(path.node.openingElement, new Set(transform.variantProps))) : t.identifier(transform.classConstName);
+		updateClassNameAttribute(path.node.openingElement, classNameExpression);
+		if (transform.propVars.length > 0) {
+			const propNames = new Set(transform.propVars.map((propVar) => propVar.propName));
+			const propValues = collectPropValuesFromJsx(path.node.openingElement, propNames);
+			if (propValues.size > 0) {
+				const assignVarsCall = buildAssignVarsCall(transform.propVars, propValues);
+				updateStyleAttribute(path.node.openingElement, assignVarsCall);
+				removeStyledProps(path.node.openingElement, propNames);
+			}
+		}
+		if (transform.variantProps.length > 0) removeStyledProps(path.node.openingElement, new Set(transform.variantProps));
+	} });
+	if (changed) {
+		ensureTypestylesRuntime(ast, {
+			style: needsStyle,
+			recipe: needsRecipe,
+			vars: needsVars
+		});
+		cleanupUnusedImports(ast);
+	}
+	const output = generate(ast, {
+		retainLines: false,
+		comments: true,
+		concise: false
+	}, source);
+	return {
+		filePath,
+		changed: changed && output.code !== source,
+		code: output.code,
+		warnings
+	};
+}
+//#endregion
+//#region src/files.ts
+const DEFAULT_EXCLUDES = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/.next/**",
+	"**/.turbo/**"
+];
+function normalizeExtension(extension) {
+	return extension.startsWith(".") ? extension : `.${extension}`;
+}
+async function collectTargetFiles(cwd, targets, extensions, include, exclude) {
+	const normalizedTargets = targets.length > 0 ? targets : ["."];
+	const literalFiles = [];
+	const dynamicPatterns = [];
+	for (const target of normalizedTargets) {
+		const absolute = resolve(cwd, target);
+		try {
+			const targetStat = await stat(absolute);
+			if (targetStat.isFile()) literalFiles.push(absolute);
+			else if (targetStat.isDirectory()) dynamicPatterns.push(`${absolute.split("\\").join("/")}/**/*`);
+		} catch {
+			dynamicPatterns.push(target);
+		}
+	}
+	const globbed = await fg(dynamicPatterns, {
+		cwd,
+		absolute: true,
+		onlyFiles: true,
+		ignore: [...DEFAULT_EXCLUDES, ...exclude]
+	});
+	const extensionSet = new Set(extensions.map(normalizeExtension));
+	const includeMatchers = include.length > 0 ? include.map((pattern) => picomatch(pattern)) : null;
+	const unique = new Set([...literalFiles, ...globbed]);
+	return Array.from(unique).filter((filePath) => extensionSet.has(extname(filePath))).filter((filePath) => {
+		if (!includeMatchers) return true;
+		const rel = relative(cwd, filePath).split("\\").join("/");
+		return includeMatchers.some((matcher) => matcher(rel));
+	}).sort();
+}
+//#endregion
+//#region src/migrate.ts
+function renderPatch(filePath, before, after) {
+	return createPatch(filePath, before, after, "before", "after").split("\n").slice(2).join("\n");
+}
+async function runMigration(cwd, options) {
+	const files = await collectTargetFiles(cwd, options.targets, options.extensions, options.include, options.exclude);
+	const reportEntries = [];
+	let changedCount = 0;
+	let warningCount = 0;
+	for (const filePath of files) {
+		const before = await readFile(filePath, "utf8");
+		const result = migrateSource(filePath, before);
+		const relativePath = relative(cwd, filePath);
+		warningCount += result.warnings.length;
+		if (result.changed) {
+			changedCount += 1;
+			if (options.write) {
+				await writeFile(filePath, result.code, "utf8");
+				process.stdout.write(`updated ${relativePath}\n`);
+			} else {
+				process.stdout.write(`\n--- ${relativePath} (dry-run) ---\n`);
+				process.stdout.write(`${renderPatch(relativePath, before, result.code)}\n`);
+			}
+		}
+		for (const warning of result.warnings) {
+			const nodeLabel = warning.nodeName ? ` (${warning.nodeName})` : "";
+			process.stdout.write(`warning ${relativePath}${nodeLabel}: ${warning.message}\n`);
+		}
+		reportEntries.push({
+			filePath: relativePath,
+			changed: result.changed,
+			warnings: result.warnings
+		});
+	}
+	const summary = {
+		filesScanned: files.length,
+		filesChanged: changedCount,
+		warnings: warningCount
+	};
+	process.stdout.write(`\nScanned ${summary.filesScanned} files, changed ${summary.filesChanged}, warnings ${summary.warnings}.\n`);
+	const report = {
+		summary,
+		files: reportEntries
+	};
+	if (options.reportPath) {
+		await mkdir(dirname(options.reportPath), { recursive: true });
+		await writeFile(options.reportPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+		process.stdout.write(`Report written to ${options.reportPath}\n`);
+	}
+	return report;
+}
+//#endregion
+export { migrateSource as n, runMigration as t };
+
+//# sourceMappingURL=migrate-DFON1MgM.js.map