@wise/wds-codemods 1.0.0-experimental-a536a63 → 1.0.0-experimental-49d2d08

package/dist/transforms/button/transformer.js

@@ -1,353 +1,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
-const require_helpers = require('../../helpers-RWhTD5Is.js');
+const require_helpers = require('../../helpers-59xSDDPO.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 iconPropName = iconChildIndex <= totalChildren - 1 - iconChildIndex ? "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") return `contains a ${expressionType} (${this.j(expr).toSource()})`;
-			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) => {
@@ -482,10 +135,10 @@ const transformer = (file, api, options) => {
 		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);
+	const reporter = require_helpers.createReporter(j, manualReviewIssues);
+	const { exists: hasButtonImport, aliases: buttonAliases, resolvedName: buttonName, conflictingImports: conflictingButtonImport } = require_helpers.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);
+	const { exists: hasActionButtonImport, remove: removeActionButtonImport, aliases: actionButtonAliases } = require_helpers.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) => {
@@ -497,12 +150,12 @@ const transformer = (file, api, options) => {
 		});
 	});
 	if (hasActionButtonImport) {
-		if (!hasButtonImport) addImport_default(root, "@transferwise/components", "Button", j);
-		findJSXElementsByName(root, j)("ActionButton", actionButtonAliases).forEach((path) => {
+		if (!hasButtonImport) require_helpers.addImport_default(root, "@transferwise/components", "Button", j);
+		require_helpers.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);
+			openingElement.name = require_helpers.setNameIfJSXIdentifier(openingElement.name, buttonName);
+			if (closingElement) closingElement.name = require_helpers.setNameIfJSXIdentifier(closingElement.name, buttonName);
+			require_helpers.iconUtils_default(j, path.node.children, iconImports, openingElement);
 			if ((openingElement.attributes ?? []).some((attr) => attr.type === "JSXSpreadAttribute")) reporter.reportSpreadProps(path);
 			const legacyPropNames = [
 				"priority",
@@ -525,7 +178,7 @@ const transformer = (file, api, options) => {
 			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, [{
+			require_helpers.addAttributesIfMissing(j, path.node.openingElement, [{
 				attribute: j.jsxAttribute(j.jsxIdentifier("v2")),
 				name: "v2"
 			}, {
@@ -541,17 +194,17 @@ const transformer = (file, api, options) => {
 		});
 		removeActionButtonImport();
 	}
-	if (hasButtonImport) findJSXElementsByName(root, j)("Button", buttonAliases).forEach((path) => {
+	if (hasButtonImport) require_helpers.findJSXElementsByName(root, j)("Button", buttonAliases).forEach((path) => {
 		const { openingElement } = path.node;
-		if (hasAttributeOnElement(openingElement, "v2")) return;
+		if (require_helpers.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, [{
+		require_helpers.addAttributesIfMissing(j, openingElement, [{
 			attribute: j.jsxAttribute(j.jsxIdentifier("v2")),
 			name: "v2"
 		}]);
-		iconUtils_default(j, path.node.children, iconImports, openingElement);
+		require_helpers.iconUtils_default(j, path.node.children, iconImports, openingElement);
 		const legacyProps = {};
 		const legacyPropNames = [
 			"priority",
@@ -587,7 +240,7 @@ const transformer = (file, api, options) => {
 					"lg",
 					"xl"
 				].includes(resolved)) {
-					removeAttributeByName(j, openingElement, "size");
+					require_helpers.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");
@@ -612,7 +265,7 @@ const transformer = (file, api, options) => {
 					"tertiary",
 					"secondary-neutral"
 				].includes(mapped)) {
-					removeAttributeByName(j, openingElement, "priority");
+					require_helpers.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");
@@ -644,20 +297,20 @@ const transformer = (file, api, options) => {
 				"reset"
 			];
 			if (resolvedType === "negative" && isControlTypeEnum) {
-				removeAttributeByName(j, openingElement, "type");
-				if (hasAttributeOnElement(openingElement, "sentiment")) removeAttributeByName(j, openingElement, "sentiment");
-				addAttributesIfMissing(j, openingElement, [{
+				require_helpers.removeAttributeByName(j, openingElement, "type");
+				if (require_helpers.hasAttributeOnElement(openingElement, "sentiment")) require_helpers.removeAttributeByName(j, openingElement, "sentiment");
+				require_helpers.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");
+				require_helpers.removeAttributeByName(j, openingElement, "type");
+				if (require_helpers.hasAttributeOnElement(openingElement, "sentiment")) require_helpers.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, [{
+				require_helpers.removeAttributeByName(j, openingElement, "type");
+				require_helpers.addAttributesIfMissing(j, openingElement, [{
 					attribute: j.jsxAttribute(j.jsxIdentifier("priority"), j.literal("primary")),
 					name: "priority"
 				}]);
@@ -665,21 +318,21 @@ const transformer = (file, api, options) => {
 			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");
+					require_helpers.removeAttributeByName(j, openingElement, "type");
+					require_helpers.removeAttributeByName(j, openingElement, "priority");
+					require_helpers.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, [{
+					require_helpers.removeAttributeByName(j, openingElement, "type");
+					require_helpers.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");
+				require_helpers.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 ?? "";
@@ -698,7 +351,7 @@ const transformer = (file, api, options) => {
 			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");
+					require_helpers.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");