@wise/wds-codemods 0.0.1 → 1.0.0

package/dist/transforms/button/transformer.js

@@ -0,0 +1,746 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_helpers = require('../../helpers-auDAwIcO.js');
+
+//#region src/helpers/addImport.ts
+/**
+* Adds a named import if it doesn't already exist.
+*/
+function addImport(root, sourceValue, importName, j) {
+	const existingImports = root.find(j.ImportDeclaration, { source: { value: sourceValue } });
+	if (existingImports.size() > 0) {
+		if (existingImports.find(j.ImportSpecifier, { imported: { name: importName } }).size() > 0) return;
+		existingImports.forEach((path) => {
+			if (path.node.specifiers) path.node.specifiers.push(j.importSpecifier(j.identifier(importName)));
+		});
+	} else {
+		const newImport = j.importDeclaration([j.importSpecifier(j.identifier(importName))], j.literal(sourceValue));
+		const firstImport = root.find(j.ImportDeclaration).at(0);
+		if (firstImport.size() > 0) firstImport.insertBefore(newImport);
+		else {
+			const program = root.find(j.Program);
+			if (program.size() > 0) program.get("body", 0).insertBefore(newImport);
+		}
+	}
+}
+var addImport_default = addImport;
+
+//#endregion
+//#region src/helpers/hasImport.ts
+/**
+* Checks if a specific import exists in the given root collection and provides
+* a method to remove it if found.
+*/
+function hasImport(root, sourceValue, importName, j) {
+	const importDeclarations = root.find(j.ImportDeclaration, { source: { value: sourceValue } });
+	/**
+	* Finds all ImportSpecifier nodes that expose `importName` but
+	* from a different source than `sourceValue`.
+	*/
+	const conflictingImports = (() => {
+		const result = [];
+		root.find(j.ImportDeclaration).filter((path) => path.node.source.value !== sourceValue).forEach((path) => {
+			for (const specifier of path.node.specifiers ?? []) if (specifier.type === "ImportSpecifier" && specifier.imported.name === importName && specifier.local?.name === importName) result.push(specifier);
+		});
+		return result;
+	})();
+	if (importDeclarations.size() === 0) return {
+		exists: false,
+		remove: () => {},
+		resolvedName: importName,
+		conflictingImports
+	};
+	const namedImport = importDeclarations.find(j.ImportSpecifier, { imported: { name: importName } });
+	const defaultImport = importDeclarations.find(j.ImportDefaultSpecifier, { local: { name: importName } });
+	const aliasImport = importDeclarations.find(j.ImportSpecifier).filter((path) => {
+		return path.node.imported.name === importName && path.node.imported.name !== path.node.local?.name;
+	});
+	const exists = namedImport.size() > 0 || defaultImport.size() > 0;
+	const resolveName = () => {
+		if (aliasImport.size() > 0) {
+			const localName = aliasImport.get(0).node.local?.name;
+			if (typeof localName === "string") return localName;
+			if (localName && typeof localName === "object" && "name" in localName && typeof localName.name === "string") return localName.name;
+			return importName;
+		}
+		return importName;
+	};
+	const remove = () => {
+		importDeclarations.forEach((path) => {
+			const filteredSpecifiers = path.node.specifiers?.filter((specifier) => {
+				if (specifier.type === "ImportSpecifier" && specifier.imported.name === importName) return false;
+				if (specifier.type === "ImportDefaultSpecifier" && specifier.local?.name === importName) return false;
+				return true;
+			}) ?? [];
+			if (filteredSpecifiers.length === 0) path.prune();
+			else j(path).replaceWith(j.importDeclaration(filteredSpecifiers, path.node.source, path.node.importKind));
+		});
+	};
+	return {
+		exists,
+		remove,
+		aliases: aliasImport,
+		resolvedName: resolveName(),
+		conflictingImports
+	};
+}
+var hasImport_default = hasImport;
+
+//#endregion
+//#region src/helpers/iconUtils.ts
+/**
+* Process children of a JSX element to detect icon components and add iconStart or iconEnd attributes accordingly.
+* This is specific to icon handling but can be reused in codemods dealing with icon children.
+*/
+const processIconChildren = (j, children, iconImports, openingElement) => {
+	if (!children || !openingElement.attributes) return;
+	const unwrapJsxElement = (node) => {
+		if (typeof node === "object" && node !== null && "type" in node && node.type === "JSXExpressionContainer" && j.JSXElement.check(node.expression)) return node.expression;
+		return node;
+	};
+	const totalChildren = children.length;
+	const iconChildIndex = children.findIndex((child) => {
+		const unwrapped = unwrapJsxElement(child);
+		return j.JSXElement.check(unwrapped) && unwrapped.openingElement.name.type === "JSXIdentifier" && iconImports.has(unwrapped.openingElement.name.name);
+	});
+	if (iconChildIndex === -1) return;
+	const iconChild = unwrapJsxElement(children[iconChildIndex]);
+	if (!iconChild || iconChild.openingElement.name.type !== "JSXIdentifier") return;
+	iconChild.openingElement.name.name;
+	const distanceToStart = iconChildIndex;
+	const distanceToEnd = totalChildren - 1 - iconChildIndex;
+	const iconPropName = distanceToStart <= distanceToEnd ? "addonStart" : "addonEnd";
+	const iconObject = j.objectExpression([j.property("init", j.identifier("type"), j.literal("icon")), j.property("init", j.identifier("value"), iconChild)]);
+	const iconProp = j.jsxAttribute(j.jsxIdentifier(iconPropName), j.jsxExpressionContainer(iconObject));
+	openingElement.attributes.push(iconProp);
+	children.splice(iconChildIndex, 1);
+	const isWhitespaceJsxText = (node) => {
+		return typeof node === "object" && node !== null && node.type === "JSXText" && typeof node.value === "string" && node.value.trim() === "";
+	};
+	if (iconChildIndex - 1 >= 0 && isWhitespaceJsxText(children[iconChildIndex - 1])) children.splice(iconChildIndex - 1, 1);
+	else if (isWhitespaceJsxText(children[iconChildIndex])) children.splice(iconChildIndex, 1);
+};
+var iconUtils_default = processIconChildren;
+
+//#endregion
+//#region src/helpers/jsxElementUtils.ts
+/**
+* Rename a JSX element name if it is a JSXIdentifier.
+*/
+const setNameIfJSXIdentifier = (elementName, newName) => {
+	if (elementName && elementName.type === "JSXIdentifier") return {
+		...elementName,
+		name: newName
+	};
+	return elementName;
+};
+/**
+* Check if a list of attributes contains a specific attribute by name.
+*/
+const hasAttribute = (attributes, attributeName) => {
+	return Array.isArray(attributes) && attributes.some((attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === attributeName);
+};
+/**
+* Check if a JSX element's openingElement has a specific attribute.
+*/
+const hasAttributeOnElement = (element, attributeName) => {
+	return hasAttribute(element.attributes, attributeName);
+};
+/**
+* Add specified attributes to a JSX element's openingElement if they are not already present.
+*/
+const addAttributesIfMissing = (j, openingElement, attributesToAdd) => {
+	if (!Array.isArray(openingElement.attributes)) return;
+	const attrs = openingElement.attributes;
+	attributesToAdd.forEach(({ attribute, name }) => {
+		if (!hasAttributeOnElement(openingElement, name)) attrs.push(attribute);
+	});
+};
+/**
+* Returns a collection of JSX elements that match the specified
+* exported name or names of the found aliases.
+*/
+const findJSXElementsByName = (root, j) => (exportedName, aliases) => {
+	const aliasNames = aliases?.size() ? aliases.paths().map((path) => path.node.local?.name) : [];
+	return root.find(j.JSXElement).filter((path) => {
+		const { name } = path.node.openingElement;
+		return name.type === "JSXIdentifier" && (name.name === exportedName || aliasNames.includes(name.name));
+	});
+};
+/**
+* Removes an attribute by name from a JSX element's openingElement.
+*/
+const removeAttributeByName = (j, openingElement, attributeName) => {
+	if (!Array.isArray(openingElement.attributes)) return;
+	openingElement.attributes = openingElement.attributes.filter((attr) => {
+		return !(attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === attributeName);
+	});
+};
+
+//#endregion
+//#region src/helpers/jsxReportingUtils.ts
+/**
+* CodemodReporter is a utility class for reporting issues found during codemod transformations.
+* It provides methods to report issues related to JSX elements, props, and attributes.
+*
+* @example
+* ```typescript
+* const issues: string[] = [];
+* const reporter = createReporter(j, issues);
+*
+* // Report a deprecated prop
+* reporter.reportDeprecatedProp(buttonElement, 'flat', 'variant="text"');
+*
+* // Report complex expression that needs review
+* reporter.reportAmbiguousExpression(element, 'size');
+*
+* // Auto-detect common issues
+* reporter.reportAttributeIssues(element);
+* ```
+*/
+var CodemodReporter = class {
+	j;
+	issues;
+	constructor(options) {
+		this.j = options.jscodeshift;
+		this.issues = options.issues;
+	}
+	/**
+	* Reports an issue with a JSX element
+	*/
+	reportElement(element, reason) {
+		const node = this.getNode(element);
+		const componentName = this.getComponentName(node);
+		const line = this.getLineNumber(node);
+		this.addIssue(`Manual review required: <${componentName}> at line ${line} ${reason}.`);
+	}
+	/**
+	* Reports an issue with a specific prop
+	*/
+	reportProp(element, propName, reason) {
+		const node = this.getNode(element);
+		const componentName = this.getComponentName(node);
+		const line = this.getLineNumber(node);
+		this.addIssue(`Manual review required: prop "${propName}" on <${componentName}> at line ${line} ${reason}.`);
+	}
+	/**
+	* Reports an issue with a JSX attribute directly
+	*/
+	reportAttribute(attr, element, reason) {
+		const node = this.getNode(element);
+		const componentName = this.getComponentName(node);
+		const propName = this.getAttributeName(attr);
+		const line = this.getLineNumber(attr) || this.getLineNumber(node);
+		const defaultReason = this.getAttributeReason(attr);
+		const finalReason = reason || defaultReason;
+		this.addIssue(`Manual review required: prop "${propName}" on <${componentName}> at line ${line} ${finalReason}.`);
+	}
+	/**
+	* Reports spread props on an element
+	*/
+	reportSpreadProps(element) {
+		this.reportElement(element, "contains spread props that need manual review");
+	}
+	/**
+	* Reports conflicting prop and children
+	*/
+	reportPropWithChildren(element, propName) {
+		this.reportProp(element, propName, `conflicts with children - both "${propName}" prop and children are present`);
+	}
+	/**
+	* Reports unsupported prop value
+	*/
+	reportUnsupportedValue(element, propName, value) {
+		this.reportProp(element, propName, `has unsupported value "${value}"`);
+	}
+	/**
+	* Reports ambiguous expression in prop
+	*/
+	reportAmbiguousExpression(element, propName) {
+		this.reportProp(element, propName, "contains a complex expression that needs manual review");
+	}
+	/**
+	* Reports ambiguous children (like dynamic icons)
+	*/
+	reportAmbiguousChildren(element, childType = "content") {
+		this.reportElement(element, `contains ambiguous ${childType} that needs manual review`);
+	}
+	/**
+	* Reports deprecated prop usage
+	*/
+	reportDeprecatedProp(element, propName, alternative) {
+		const suggestion = alternative ? ` Use ${alternative} instead` : "";
+		this.reportProp(element, propName, `is deprecated${suggestion}`);
+	}
+	/**
+	* Reports missing required prop
+	*/
+	reportMissingRequiredProp(element, propName) {
+		this.reportProp(element, propName, "is required but missing");
+	}
+	/**
+	* Reports conflicting props
+	*/
+	reportConflictingProps(element, propNames) {
+		const propList = propNames.map((name) => `"${name}"`).join(", ");
+		this.reportElement(element, `has conflicting props: ${propList} cannot be used together`);
+	}
+	/**
+	* Auto-detects and reports common attribute issues
+	*/
+	reportAttributeIssues(element) {
+		const { attributes } = this.getNode(element).openingElement;
+		if (!attributes) return;
+		if (attributes.some((attr) => attr.type === "JSXSpreadAttribute")) this.reportSpreadProps(element);
+		attributes.forEach((attr) => {
+			if (attr.type === "JSXAttribute" && attr.value?.type === "JSXExpressionContainer") this.reportAttribute(attr, element);
+		});
+	}
+	/**
+	* Finds and reports instances of components that are under an alias (imported with a different name)
+	*/
+	reportAliases(element) {
+		this.reportElement(element, "is used via an import alias and needs manual review");
+	}
+	/**
+	* Finds and reports instances of non-DS import declarations that conflict with the component name
+	*/
+	reportConflictingImports(node) {
+		this.addIssue(`Manual review required: Non-WDS package resulting in an import conflict at line ${this.getLineNumber(node)}.`);
+	}
+	/**
+	* Reports enum usage for future conversion tracking
+	*/
+	reportEnumUsage(element, propName, enumValue) {
+		this.reportProp(element, propName, `uses enum value "${enumValue}" which has been preserved but should be migrated to a string literal in the future`);
+	}
+	getNode(element) {
+		return "node" in element ? element.node : element;
+	}
+	getComponentName(node) {
+		const { name } = node.openingElement;
+		if (name.type === "JSXIdentifier") return name.name;
+		return this.j(name).toSource();
+	}
+	getLineNumber(node) {
+		return node.loc?.start.line?.toString() || "unknown";
+	}
+	getAttributeName(attr) {
+		if (attr.name.type === "JSXIdentifier") return attr.name.name;
+		return this.j(attr.name).toSource();
+	}
+	getAttributeReason(attr) {
+		if (!attr.value) return "has no value";
+		if (attr.value.type === "JSXExpressionContainer") {
+			const expr = attr.value.expression;
+			const expressionType = expr.type.replace("Expression", "").toLowerCase();
+			if (expr.type === "Identifier" || expr.type === "MemberExpression") {
+				const valueText = this.j(expr).toSource();
+				return `contains a ${expressionType} (${valueText})`;
+			}
+			return `contains a complex ${expressionType} expression`;
+		}
+		return "needs manual review";
+	}
+	addIssue(message) {
+		this.issues.push(message);
+	}
+};
+const createReporter = (j, issues) => {
+	return new CodemodReporter({
+		jscodeshift: j,
+		issues
+	});
+};
+
+//#endregion
+//#region src/transforms/button/transformer.ts
+const parser = "tsx";
+const buildPriorityMapping = (opts) => {
+	const extendedOpts = opts;
+	const accentSecondary = extendedOpts.accentSecondaryMapping || "secondary-neutral";
+	const positiveSecondary = extendedOpts.positiveSecondaryMapping || "secondary-neutral";
+	return {
+		accent: {
+			primary: "primary",
+			secondary: accentSecondary,
+			tertiary: "tertiary"
+		},
+		positive: {
+			primary: "primary",
+			secondary: positiveSecondary,
+			tertiary: positiveSecondary
+		},
+		negative: {
+			primary: "primary",
+			secondary: "secondary",
+			tertiary: "secondary"
+		},
+		primary: {
+			primary: "primary",
+			secondary: accentSecondary,
+			tertiary: "tertiary"
+		},
+		pay: {
+			primary: "primary",
+			secondary: accentSecondary,
+			tertiary: accentSecondary
+		}
+	};
+};
+const sizeMap = {
+	EXTRA_SMALL: "xs",
+	SMALL: "sm",
+	MEDIUM: "md",
+	LARGE: "lg",
+	EXTRA_LARGE: "xl",
+	xs: "sm",
+	sm: "sm",
+	md: "md",
+	lg: "lg",
+	xl: "xl"
+};
+const resolveSize = (size) => {
+	if (!size) return size;
+	const match = /^Size\.(EXTRA_SMALL|SMALL|MEDIUM|LARGE|EXTRA_LARGE)$/u.exec(size);
+	if (match) return sizeMap[match[1]];
+	return sizeMap[size] || size;
+};
+const legacyButtonTypes = [
+	"accent",
+	"negative",
+	"positive",
+	"primary",
+	"pay",
+	"secondary",
+	"danger",
+	"link"
+];
+const getConsistentTypeConversions = (type) => {
+	return {
+		secondary: { priority: "secondary-neutral" },
+		link: { priority: "tertiary" },
+		danger: {
+			priority: "secondary",
+			sentiment: "negative"
+		}
+	}[type || ""] || null;
+};
+const convertEnumValue = (value) => {
+	if (!value) return value;
+	const strippedValue = value.replace(/^['"]|['"]$/gu, "");
+	return {
+		"Priority.SECONDARY": "secondary",
+		"Priority.PRIMARY": "primary",
+		"Priority.TERTIARY": "tertiary",
+		"ControlType.NEGATIVE": "negative",
+		"ControlType.POSITIVE": "positive",
+		"ControlType.ACCENT": "accent"
+	}[strippedValue] || strippedValue;
+};
+/**
+* Detects if a value is an enum pattern (e.g., Priority.PRIMARY, ControlType.ACCENT, Size.LARGE, Type.PRIMARY)
+*/
+const isEnumValue = (value) => {
+	return [
+		/^Priority\.(PRIMARY|SECONDARY|TERTIARY|SECONDARY_NEUTRAL)$/u,
+		/^ControlType\.(ACCENT|NEGATIVE|POSITIVE)$/u,
+		/^Size\.(EXTRA_SMALL|SMALL|MEDIUM|LARGE|EXTRA_LARGE)$/u,
+		/^Type\.(PRIMARY|SECONDARY|TERTIARY|PAY|DANGER|LINK|ACCENT|POSITIVE|NEGATIVE)$/u
+	].some((pattern) => pattern.test(value));
+};
+/**
+* Maps enum values to their expected string equivalents for validation purposes
+* This is ONLY used to validate the enum maps to a supported value
+*/
+const getEnumEquivalent = (value) => {
+	return {
+		"Priority.PRIMARY": "primary",
+		"Priority.SECONDARY": "secondary",
+		"Priority.TERTIARY": "tertiary",
+		"Priority.SECONDARY_NEUTRAL": "secondary-neutral",
+		"ControlType.NEGATIVE": "negative",
+		"ControlType.POSITIVE": "positive",
+		"ControlType.ACCENT": "accent",
+		"Size.EXTRA_SMALL": "sm",
+		"Size.SMALL": "sm",
+		"Size.MEDIUM": "md",
+		"Size.LARGE": "lg",
+		"Size.EXTRA_LARGE": "xl"
+	}[value];
+};
+/**
+* This transform function modifies the Button and ActionButton components from the @transferwise/components library.
+* It updates the ActionButton component to use the Button component with specific attributes and mappings.
+* It also processes icon children and removes legacy props.
+*
+* @param {FileInfo} file - The file information object.
+* @param {API} api - The API object for jscodeshift.
+* @param {Options} options - The options object for jscodeshift.
+* @returns {string} - The transformed source code.
+*/
+const transformer = (file, api, options) => {
+	const j = api.jscodeshift;
+	const root = j(file.source);
+	const manualReviewIssues = [];
+	const priorityMapping = buildPriorityMapping(options);
+	const resolvePriority = (type, priority) => {
+		if (type && priority) return priorityMapping[type]?.[priority] || priority;
+		return priority;
+	};
+	const reporter = createReporter(j, manualReviewIssues);
+	const { exists: hasButtonImport, aliases: buttonAliases, resolvedName: buttonName, conflictingImports: conflictingButtonImport } = hasImport_default(root, "@transferwise/components", "Button", j);
+	if (conflictingButtonImport.length) conflictingButtonImport.forEach((node) => reporter.reportConflictingImports(node));
+	const { exists: hasActionButtonImport, remove: removeActionButtonImport, aliases: actionButtonAliases } = hasImport_default(root, "@transferwise/components", "ActionButton", j);
+	if (!hasButtonImport && !hasActionButtonImport) return file.source;
+	const iconImports = /* @__PURE__ */ new Set();
+	root.find(j.ImportDeclaration, { source: { value: "@transferwise/icons" } }).forEach((path) => {
+		path.node.specifiers?.forEach((specifier) => {
+			if ((specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportSpecifier") && specifier.local) {
+				const localName = specifier.local.name;
+				iconImports.add(localName);
+			}
+		});
+	});
+	if (hasActionButtonImport) {
+		if (!hasButtonImport) addImport_default(root, "@transferwise/components", "Button", j);
+		findJSXElementsByName(root, j)("ActionButton", actionButtonAliases).forEach((path) => {
+			const { openingElement, closingElement } = path.node;
+			openingElement.name = setNameIfJSXIdentifier(openingElement.name, buttonName);
+			if (closingElement) closingElement.name = setNameIfJSXIdentifier(closingElement.name, buttonName);
+			iconUtils_default(j, path.node.children, iconImports, openingElement);
+			if ((openingElement.attributes ?? []).some((attr) => attr.type === "JSXSpreadAttribute")) reporter.reportSpreadProps(path);
+			const legacyPropNames = [
+				"priority",
+				"text",
+				"size"
+			];
+			const legacyProps = {};
+			openingElement.attributes?.forEach((attr) => {
+				if (attr.type === "JSXAttribute" && attr.name && attr.name.type === "JSXIdentifier") {
+					const { name } = attr.name;
+					if (legacyPropNames.includes(name)) {
+						if (attr.value) {
+							if (attr.value.type === "StringLiteral") legacyProps[name] = attr.value.value;
+							else if (attr.value.type === "JSXExpressionContainer") legacyProps[name] = convertEnumValue(String(j(attr.value.expression).toSource()));
+						}
+					}
+				}
+			});
+			const hasTextProp = "text" in legacyProps;
+			const hasChildren = path.node.children?.some((child) => child.type === "JSXText" && child.value.trim() !== "" || child.type === "JSXElement" || child.type === "JSXExpressionContainer") || path.node.children && path.node.children?.length > 0;
+			if (hasTextProp && hasChildren) reporter.reportPropWithChildren(path, "text");
+			else if (hasTextProp && !hasChildren && openingElement.selfClosing) path.replace(j.jsxElement(j.jsxOpeningElement(openingElement.name, openingElement.attributes), j.jsxClosingElement(openingElement.name), [j.jsxText(legacyProps.text || "")]));
+			addAttributesIfMissing(j, path.node.openingElement, [{
+				attribute: j.jsxAttribute(j.jsxIdentifier("v2")),
+				name: "v2"
+			}, {
+				attribute: j.jsxAttribute(j.jsxIdentifier("size"), j.literal("sm")),
+				name: "size"
+			}]);
+			(path.node.children || []).forEach((child) => {
+				if (child.type === "JSXExpressionContainer") {
+					const expr = child.expression;
+					if (expr.type === "ConditionalExpression" || expr.type === "CallExpression" || expr.type === "Identifier" || expr.type === "MemberExpression") reporter.reportAmbiguousChildren(path, "icon");
+				}
+			});
+		});
+		removeActionButtonImport();
+	}
+	if (hasButtonImport) findJSXElementsByName(root, j)("Button", buttonAliases).forEach((path) => {
+		const { openingElement } = path.node;
+		if (hasAttributeOnElement(openingElement, "v2")) return;
+		const hasJSXChildren = path.node.children?.some((child) => child.type === "JSXText" && child.value.trim() !== "" || child.type === "JSXElement" || child.type === "JSXFragment" && child.children && child.children.length > 0 || child.type === "JSXExpressionContainer" && child.expression.type !== "JSXEmptyExpression");
+		const hasChildrenAsProp = openingElement.attributes?.some((attr) => attr.type === "JSXAttribute" && attr.name?.type === "JSXIdentifier" && attr.name.name === "children");
+		if (!hasJSXChildren && !hasChildrenAsProp) return;
+		addAttributesIfMissing(j, openingElement, [{
+			attribute: j.jsxAttribute(j.jsxIdentifier("v2")),
+			name: "v2"
+		}]);
+		iconUtils_default(j, path.node.children, iconImports, openingElement);
+		const legacyProps = {};
+		const legacyPropNames = [
+			"priority",
+			"size",
+			"type",
+			"htmlType",
+			"sentiment"
+		];
+		openingElement.attributes?.forEach((attr) => {
+			if (attr.type === "JSXAttribute" && attr.name && attr.name.type === "JSXIdentifier") {
+				const { name } = attr.name;
+				if (legacyPropNames.includes(name)) if (attr.value) {
+					if (attr.value.type === "StringLiteral") legacyProps[name] = attr.value.value;
+					else if (attr.value.type === "JSXExpressionContainer") legacyProps[name] = String(j(attr.value.expression).toSource());
+				} else legacyProps[name] = void 0;
+			}
+		});
+		if ("size" in legacyProps) {
+			const rawValue = legacyProps.size;
+			if (typeof rawValue === "string" && isEnumValue(rawValue)) {
+				const equivalent = getEnumEquivalent(rawValue);
+				if (equivalent && [
+					"sm",
+					"md",
+					"lg",
+					"xl"
+				].includes(equivalent)) {} else reporter.reportUnsupportedValue(path, "size", rawValue);
+			} else {
+				const resolved = resolveSize(rawValue);
+				if (typeof rawValue === "string" && typeof resolved === "string" && [
+					"sm",
+					"md",
+					"lg",
+					"xl"
+				].includes(resolved)) {
+					removeAttributeByName(j, openingElement, "size");
+					openingElement.attributes?.push(j.jsxAttribute(j.jsxIdentifier("size"), j.literal(resolved)));
+				} else if (typeof rawValue === "string") reporter.reportUnsupportedValue(path, "size", rawValue);
+				else if (rawValue !== void 0) reporter.reportAmbiguousExpression(path, "size");
+			}
+		}
+		if ("priority" in legacyProps) {
+			const rawValue = legacyProps.priority;
+			if (typeof rawValue === "string" && isEnumValue(rawValue)) {
+				const equivalent = getEnumEquivalent(rawValue);
+				if (equivalent && [
+					"primary",
+					"secondary",
+					"tertiary",
+					"secondary-neutral"
+				].includes(equivalent)) {} else reporter.reportUnsupportedValue(path, "priority", rawValue);
+			} else {
+				const converted = convertEnumValue(rawValue);
+				const mapped = resolvePriority(legacyProps.type, converted);
+				if (typeof rawValue === "string" && typeof mapped === "string" && [
+					"primary",
+					"secondary",
+					"tertiary",
+					"secondary-neutral"
+				].includes(mapped)) {
+					removeAttributeByName(j, openingElement, "priority");
+					openingElement.attributes?.push(j.jsxAttribute(j.jsxIdentifier("priority"), j.literal(mapped)));
+				} else if (typeof rawValue === "string") reporter.reportUnsupportedValue(path, "priority", rawValue);
+				else if (rawValue !== void 0) reporter.reportAmbiguousExpression(path, "priority");
+			}
+		}
+		if ("type" in legacyProps || "htmlType" in legacyProps) {
+			const rawType = legacyProps.type;
+			const rawHtmlType = legacyProps.htmlType;
+			let resolvedType;
+			let isTypeEnum = false;
+			let isControlTypeEnum = false;
+			if (typeof rawType === "string" && isEnumValue(rawType)) {
+				isTypeEnum = true;
+				resolvedType = getEnumEquivalent(rawType);
+				isControlTypeEnum = rawType.startsWith("ControlType.");
+				if (!isControlTypeEnum) reporter.reportUnsupportedValue(path, "type", rawType);
+			} else {
+				let typeValue;
+				if (typeof rawType === "string") typeValue = rawType;
+				else if (rawType && typeof rawType === "object") typeValue = convertEnumValue(j(rawType).toSource());
+				resolvedType = typeValue;
+			}
+			let finalHtmlType = null;
+			if (resolvedType && !legacyButtonTypes.includes(resolvedType)) finalHtmlType = resolvedType;
+			if (rawHtmlType) finalHtmlType = rawHtmlType;
+			const htmlTypes = [
+				"submit",
+				"button",
+				"reset"
+			];
+			if (resolvedType === "negative" && isControlTypeEnum) {
+				removeAttributeByName(j, openingElement, "type");
+				if (hasAttributeOnElement(openingElement, "sentiment")) removeAttributeByName(j, openingElement, "sentiment");
+				addAttributesIfMissing(j, openingElement, [{
+					attribute: j.jsxAttribute(j.jsxIdentifier("priority"), j.literal("primary")),
+					name: "priority"
+				}]);
+				if (rawType) openingElement.attributes?.push(j.jsxAttribute(j.jsxIdentifier("sentiment"), j.jsxExpressionContainer(j.identifier(rawType))));
+			} else if (resolvedType === "negative" && !isTypeEnum) {
+				removeAttributeByName(j, openingElement, "type");
+				if (hasAttributeOnElement(openingElement, "sentiment")) removeAttributeByName(j, openingElement, "sentiment");
+				openingElement.attributes?.push(j.jsxAttribute(j.jsxIdentifier("sentiment"), j.literal("negative")));
+			} else if (isControlTypeEnum && resolvedType && ["positive", "accent"].includes(resolvedType)) {
+				removeAttributeByName(j, openingElement, "type");
+				addAttributesIfMissing(j, openingElement, [{
+					attribute: j.jsxAttribute(j.jsxIdentifier("priority"), j.literal("primary")),
+					name: "priority"
+				}]);
+			}
+			if (resolvedType && typeof resolvedType === "string" && legacyButtonTypes.includes(resolvedType) && !isTypeEnum) {
+				const consistentConversion = getConsistentTypeConversions(resolvedType);
+				if (consistentConversion) {
+					removeAttributeByName(j, openingElement, "type");
+					removeAttributeByName(j, openingElement, "priority");
+					removeAttributeByName(j, openingElement, "sentiment");
+					if (consistentConversion.priority) openingElement.attributes?.push(j.jsxAttribute(j.jsxIdentifier("priority"), j.literal(consistentConversion.priority)));
+					if (consistentConversion.sentiment) openingElement.attributes?.push(j.jsxAttribute(j.jsxIdentifier("sentiment"), j.literal(consistentConversion.sentiment)));
+				} else {
+					removeAttributeByName(j, openingElement, "type");
+					addAttributesIfMissing(j, openingElement, [{
+						attribute: j.jsxAttribute(j.jsxIdentifier("priority"), j.literal("primary")),
+						name: "priority"
+					}]);
+				}
+			} else if (isTypeEnum) {}
+			if (typeof finalHtmlType === "string" && htmlTypes.includes(finalHtmlType)) {
+				removeAttributeByName(j, openingElement, "htmlType");
+				openingElement.attributes?.push(j.jsxAttribute(j.jsxIdentifier("type"), j.literal(finalHtmlType)));
+			} else if (typeof rawType === "string" || typeof rawHtmlType === "string") {
+				const valueToCheck = rawType ?? rawHtmlType ?? "";
+				if (![
+					"accent",
+					"positive",
+					"negative",
+					"primary",
+					"secondary",
+					"danger",
+					"link"
+				].includes(valueToCheck)) reporter.reportUnsupportedValue(path, "type", valueToCheck);
+			} else if (rawType !== void 0 || rawHtmlType !== void 0) reporter.reportAmbiguousExpression(path, typeof rawType === "string" ? "type" : "htmlType");
+		}
+		if ("sentiment" in legacyProps) {
+			if (!openingElement.attributes?.some((attr) => attr.type === "JSXAttribute" && attr.name && attr.name.name === "sentiment")) {
+				const rawValue = legacyProps.sentiment;
+				if (rawValue === "negative") {
+					removeAttributeByName(j, openingElement, "sentiment");
+					openingElement.attributes?.push(j.jsxAttribute(j.jsxIdentifier("sentiment"), j.literal("negative")));
+				} else if (typeof rawValue === "string") reporter.reportUnsupportedValue(path, "sentiment", rawValue);
+				else if (rawValue !== void 0) reporter.reportAmbiguousExpression(path, "sentiment");
+			}
+		}
+		let asIndex = -1;
+		let asValue = null;
+		let hrefExists = false;
+		openingElement.attributes?.forEach((attr, index) => {
+			if (attr.type === "JSXAttribute" && attr.name) {
+				if (attr.name.name === "as") {
+					if (attr.value) {
+						if (attr.value.type === "StringLiteral") asValue = attr.value.value;
+						else if (attr.value.type === "JSXExpressionContainer") reporter.reportAttribute(attr, path);
+					}
+					asIndex = index;
+				}
+				if (attr.name.name === "href") {
+					hrefExists = true;
+					if (attr.value && attr.value.type !== "StringLiteral") reporter.reportAttribute(attr, path);
+				}
+			}
+		});
+		if (asValue === "a") {
+			if (asIndex !== -1) openingElement.attributes = openingElement.attributes?.filter((_attr, idx) => idx !== asIndex);
+			if (!hrefExists) openingElement.attributes = [...openingElement.attributes ?? [], j.jsxAttribute(j.jsxIdentifier("href"), j.literal("#"))];
+		}
+		if ((openingElement.attributes ?? []).some((attr) => attr.type === "JSXSpreadAttribute")) reporter.reportSpreadProps(path);
+	});
+	if (manualReviewIssues.length > 0) manualReviewIssues.forEach(async (issue) => {
+		await require_helpers.reportManualReview_default(file.path, issue);
+	});
+	return root.toSource();
+};
+var transformer_default = transformer;
+
+//#endregion
+exports.default = transformer_default;
+exports.parser = parser;
+//# sourceMappingURL=transformer.js.map