@wise/wds-codemods 0.0.1-experimental-cbae00f → 0.0.1-experimental-926a862

package/dist/transforms/button.js

@@ -1,589 +1,516 @@
-// src/utils/reportManualReview.ts
-import fs from "fs/promises";
-import path from "path";
-var REPORT_PATH = path.resolve(process.cwd(), "codemod-report.txt");
-var reportManualReview = async (filePath, message) => {
-  const lineMatch = /at line (\d+)/u.exec(message);
-  const lineNumber = lineMatch?.[1];
-  const cleanMessage = message.replace(/ at line \d+/u, "");
-  const lineInfo = lineNumber ? `:${lineNumber}` : "";
-  await fs.appendFile(REPORT_PATH, `[${filePath}${lineInfo}] ${cleanMessage}
-`, "utf8");
-};
-var reportManualReview_default = reportManualReview;
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_reportManualReview = require('../reportManualReview-DQ00-OKx.js');
 
-// src/transforms/helpers/hasImport.ts
+//#region src/transforms/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 }
-  });
-  if (importDeclarations.size() === 0) {
-    return {
-      exists: false,
-      remove: () => {
-      }
-    };
-  }
-  const namedImport = importDeclarations.find(j.ImportSpecifier, {
-    imported: { name: importName }
-  });
-  const defaultImport = importDeclarations.find(j.ImportDefaultSpecifier, {
-    local: { name: importName }
-  });
-  const exists = namedImport.size() > 0 || defaultImport.size() > 0;
-  const remove = () => {
-    importDeclarations.forEach((path2) => {
-      const filteredSpecifiers = path2.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) {
-        path2.prune();
-      } else {
-        j(path2).replaceWith(
-          j.importDeclaration(filteredSpecifiers, path2.node.source, path2.node.importKind)
-        );
-      }
-    });
-  };
-  return { exists, remove };
+	const importDeclarations = root.find(j.ImportDeclaration, { source: { value: sourceValue } });
+	if (importDeclarations.size() === 0) return {
+		exists: false,
+		remove: () => {}
+	};
+	const namedImport = importDeclarations.find(j.ImportSpecifier, { imported: { name: importName } });
+	const defaultImport = importDeclarations.find(j.ImportDefaultSpecifier, { local: { name: importName } });
+	const exists = namedImport.size() > 0 || defaultImport.size() > 0;
+	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
+	};
 }
-var hasImport_default = hasImport;
 
-// src/transforms/helpers/iconUtils.ts
-var 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;
-  const iconName = 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);
-  }
+//#endregion
+//#region src/transforms/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;
 
-// src/transforms/helpers/jsxElementUtils.ts
-var setNameIfJSXIdentifier = (elementName, newName) => {
-  if (elementName && elementName.type === "JSXIdentifier") {
-    return { ...elementName, name: newName };
-  }
-  return elementName;
+//#endregion
+//#region src/transforms/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;
 };
-var hasAttribute = (attributes, attributeName) => {
-  return Array.isArray(attributes) && attributes.some(
-    (attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === attributeName
-  );
+/**
+* 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);
 };
-var hasAttributeOnElement = (element, attributeName) => {
-  return hasAttribute(element.attributes, attributeName);
+/**
+* Check if a JSX element's openingElement has a specific attribute.
+*/
+const hasAttributeOnElement = (element, attributeName) => {
+	return hasAttribute(element.attributes, attributeName);
 };
-var 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);
-    }
-  });
+/**
+* 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);
+	});
 };
 
-// src/transforms/helpers/jsxReportingUtils.ts
+//#endregion
+//#region src/transforms/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 node = this.getNode(element);
-    const { attributes } = node.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);
-      }
-    });
-  }
-  // Private helper methods
-  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);
-  }
+	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 node = this.getNode(element);
+		const { attributes } = node.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);
+		});
+	}
+	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);
+	}
 };
-var createReporter = (j, issues) => {
-  return new CodemodReporter({ jscodeshift: j, issues });
+const createReporter = (j, issues) => {
+	return new CodemodReporter({
+		jscodeshift: j,
+		issues
+	});
 };
 
-// src/transforms/button/button.ts
-var parser = "tsx";
-var priorityMapping = {
-  accent: {
-    primary: "primary",
-    secondary: "secondary-neutral",
-    tertiary: "tertiary"
-  },
-  positive: {
-    primary: "primary",
-    secondary: "secondary-neutral",
-    tertiary: "secondary-neutral"
-  },
-  negative: {
-    primary: "primary",
-    secondary: "secondary",
-    tertiary: "secondary"
-  }
-};
-var sizeMap = {
-  EXTRA_SMALL: "xs",
-  SMALL: "sm",
-  MEDIUM: "md",
-  LARGE: "lg",
-  EXTRA_LARGE: "xl",
-  xs: "sm",
-  sm: "sm",
-  md: "md",
-  lg: "lg",
-  xl: "xl"
+//#endregion
+//#region src/transforms/button/transformer.ts
+const parser = "tsx";
+const priorityMapping = {
+	accent: {
+		primary: "primary",
+		secondary: "secondary-neutral",
+		tertiary: "tertiary"
+	},
+	positive: {
+		primary: "primary",
+		secondary: "secondary-neutral",
+		tertiary: "secondary-neutral"
+	},
+	negative: {
+		primary: "primary",
+		secondary: "secondary",
+		tertiary: "secondary"
+	}
 };
-var 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 sizeMap = {
+	EXTRA_SMALL: "xs",
+	SMALL: "sm",
+	MEDIUM: "md",
+	LARGE: "lg",
+	EXTRA_LARGE: "xl",
+	xs: "sm",
+	sm: "sm",
+	md: "md",
+	lg: "lg",
+	xl: "xl"
 };
-var resolvePriority = (type, priority) => {
-  if (type && priority) {
-    return priorityMapping[type]?.[priority] || priority;
-  }
-  return priority;
+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;
 };
-var resolveType = (type, htmlType) => {
-  if (htmlType) {
-    return htmlType;
-  }
-  const legacyButtonTypes = [
-    "accent",
-    "negative",
-    "positive",
-    "primary",
-    "pay",
-    "secondary",
-    "danger",
-    "link"
-  ];
-  return type && legacyButtonTypes.includes(type) ? type : null;
+const resolvePriority = (type, priority) => {
+	if (type && priority) return priorityMapping[type]?.[priority] || priority;
+	return priority;
 };
-var convertEnumValue = (value) => {
-  if (!value) return value;
-  const strippedValue = value.replace(/^['"]|['"]$/gu, "");
-  const enumMapping = {
-    "Priority.SECONDARY": "secondary",
-    "Priority.PRIMARY": "primary",
-    "Priority.TERTIARY": "tertiary",
-    "ControlType.NEGATIVE": "negative",
-    "ControlType.POSITIVE": "positive",
-    "ControlType.ACCENT": "accent"
-  };
-  return enumMapping[strippedValue] || strippedValue;
+const resolveType = (type, htmlType) => {
+	if (htmlType) return htmlType;
+	const legacyButtonTypes = [
+		"accent",
+		"negative",
+		"positive",
+		"primary",
+		"pay",
+		"secondary",
+		"danger",
+		"link"
+	];
+	return type && legacyButtonTypes.includes(type) ? type : null;
 };
-var transformer = (file, api, options) => {
-  const j = api.jscodeshift;
-  const root = j(file.source);
-  const manualReviewIssues = [];
-  const reporter = createReporter(j, manualReviewIssues);
-  const { exists: hasButtonImport } = hasImport_default(root, "@transferwise/components", "Button", j);
-  const { exists: hasActionButtonImport, remove: removeActionButtonImport } = hasImport_default(
-    root,
-    "@transferwise/components",
-    "ActionButton",
-    j
-  );
-  const iconImports = /* @__PURE__ */ new Set();
-  root.find(j.ImportDeclaration, { source: { value: "@transferwise/icons" } }).forEach((path2) => {
-    path2.node.specifiers?.forEach((specifier) => {
-      if ((specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportSpecifier") && specifier.local) {
-        const localName = specifier.local.name;
-        iconImports.add(localName);
-      }
-    });
-  });
-  if (hasActionButtonImport) {
-    root.findJSXElements("ActionButton").forEach((path2) => {
-      const { openingElement, closingElement } = path2.node;
-      openingElement.name = setNameIfJSXIdentifier(openingElement.name, "Button");
-      if (closingElement) {
-        closingElement.name = setNameIfJSXIdentifier(closingElement.name, "Button");
-      }
-      addAttributesIfMissing(j, openingElement, [
-        { attribute: j.jsxAttribute(j.jsxIdentifier("v2")), name: "v2" },
-        { attribute: j.jsxAttribute(j.jsxIdentifier("size"), j.literal("sm")), name: "size" }
-      ]);
-      iconUtils_default(j, path2.node.children, iconImports, openingElement);
-      if ((openingElement.attributes ?? []).some((attr) => attr.type === "JSXSpreadAttribute")) {
-        reporter.reportSpreadProps(path2);
-      }
-      const legacyPropNames = ["priority", "text"];
-      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") {
-                reporter.reportAttribute(attr, path2);
-              }
-            }
-          }
-        }
-      });
-      const hasTextProp = openingElement.attributes?.some(
-        (attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === "text"
-      );
-      const hasChildren = path2.node.children?.some(
-        (child) => child.type === "JSXText" && child.value.trim() !== "" || child.type === "JSXElement" || child.type === "JSXExpressionContainer"
-      );
-      if (hasTextProp && hasChildren) {
-        reporter.reportPropWithChildren(path2, "text");
-      }
-      (path2.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(path2, "icon");
-          }
-        }
-      });
-    });
-    removeActionButtonImport();
-  }
-  if (hasButtonImport) {
-    root.findJSXElements("Button").forEach((path2) => {
-      const { openingElement } = path2.node;
-      if (hasAttributeOnElement(openingElement, "v2")) return;
-      addAttributesIfMissing(j, openingElement, [
-        { attribute: j.jsxAttribute(j.jsxIdentifier("v2")), name: "v2" }
-      ]);
-      iconUtils_default(j, path2.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] = convertEnumValue(String(j(attr.value.expression).toSource()));
-              }
-            } else {
-              legacyProps[name] = void 0;
-            }
-          }
-        }
-      });
-      if (openingElement.attributes) {
-        openingElement.attributes = openingElement.attributes.filter(
-          (attr) => !(attr.type === "JSXAttribute" && attr.name && legacyPropNames.includes(attr.name.name))
-        );
-      }
-      if ("size" in legacyProps) {
-        const rawValue = legacyProps.size;
-        const resolved = resolveSize(rawValue);
-        const supportedSizes = ["xs", "sm", "md", "lg", "xl"];
-        if (typeof rawValue === "string" && typeof resolved === "string" && supportedSizes.includes(resolved)) {
-          openingElement.attributes?.push(
-            j.jsxAttribute(j.jsxIdentifier("size"), j.literal(resolved))
-          );
-        } else if (typeof rawValue === "string") {
-          reporter.reportUnsupportedValue(path2, "size", rawValue);
-        } else if (rawValue !== void 0) {
-          reporter.reportAmbiguousExpression(path2, "size");
-        }
-      }
-      if ("priority" in legacyProps) {
-        const rawValue = legacyProps.priority;
-        const converted = convertEnumValue(rawValue);
-        const mapped = resolvePriority(legacyProps.type, converted);
-        const supportedPriorities = ["primary", "secondary", "tertiary", "secondary-neutral"];
-        if (typeof rawValue === "string" && typeof mapped === "string" && supportedPriorities.includes(mapped)) {
-          openingElement.attributes?.push(
-            j.jsxAttribute(j.jsxIdentifier("priority"), j.literal(mapped))
-          );
-        } else if (typeof rawValue === "string") {
-          reporter.reportUnsupportedValue(path2, "priority", rawValue);
-        } else if (rawValue !== void 0) {
-          reporter.reportAmbiguousExpression(path2, "priority");
-        }
-      }
-      if ("type" in legacyProps || "htmlType" in legacyProps) {
-        const rawType = legacyProps.type;
-        const rawHtmlType = legacyProps.htmlType;
-        const resolvedType = typeof rawType === "string" ? rawType : rawType && typeof rawType === "object" ? convertEnumValue(j(rawType).toSource()) : void 0;
-        const resolved = resolveType(resolvedType, rawHtmlType);
-        const supportedTypes = [
-          "accent",
-          "negative",
-          "positive",
-          "primary",
-          "pay",
-          "secondary",
-          "danger",
-          "link",
-          "submit",
-          "button",
-          "reset"
-        ];
-        if (typeof resolved === "string" && supportedTypes.includes(resolved)) {
-          openingElement.attributes?.push(
-            j.jsxAttribute(j.jsxIdentifier("type"), j.literal(resolved))
-          );
-          if (resolved === "negative") {
-            openingElement.attributes?.push(
-              j.jsxAttribute(j.jsxIdentifier("sentiment"), j.literal("negative"))
-            );
-          }
-        } else if (typeof rawType === "string" || typeof rawHtmlType === "string") {
-          reporter.reportUnsupportedValue(path2, "type", rawType ?? rawHtmlType ?? "");
-        } else if (rawType !== void 0 || rawHtmlType !== void 0) {
-          reporter.reportAmbiguousExpression(path2, "type");
-        }
-      }
-      if ("sentiment" in legacyProps) {
-        const rawValue = legacyProps.sentiment;
-        if (rawValue === "negative") {
-          openingElement.attributes?.push(
-            j.jsxAttribute(j.jsxIdentifier("sentiment"), j.literal("negative"))
-          );
-        } else if (typeof rawValue === "string") {
-          reporter.reportUnsupportedValue(path2, "sentiment", rawValue);
-        } else if (rawValue !== void 0) {
-          reporter.reportAmbiguousExpression(path2, "sentiment");
-        }
-      }
-      let asIndex = -1;
-      let asValue = null;
-      let hrefExists = false;
-      let asAmbiguous = false;
-      let hrefAmbiguous = 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") {
-                asAmbiguous = true;
-                reporter.reportAttribute(attr, path2);
-              }
-            }
-            asIndex = index;
-          }
-          if (attr.name.name === "href") {
-            hrefExists = true;
-            if (attr.value && attr.value.type !== "StringLiteral") {
-              hrefAmbiguous = true;
-              reporter.reportAttribute(attr, path2);
-            }
-          }
-        }
-      });
-      if (asValue && asValue !== "a") {
-        reporter.reportUnsupportedValue(path2, "as", asValue);
-      }
-      if (asValue === "a") {
-        if (asIndex !== -1) {
-          openingElement.attributes = openingElement.attributes?.filter(
-            (_, 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(path2);
-      }
-    });
-  }
-  if (manualReviewIssues.length > 0) {
-    manualReviewIssues.forEach(async (issue) => {
-      await reportManualReview_default(file.path, issue);
-    });
-  }
-  return root.toSource();
+const convertEnumValue = (value) => {
+	if (!value) return value;
+	const strippedValue = value.replace(/^['"]|['"]$/gu, "");
+	const enumMapping = {
+		"Priority.SECONDARY": "secondary",
+		"Priority.PRIMARY": "primary",
+		"Priority.TERTIARY": "tertiary",
+		"ControlType.NEGATIVE": "negative",
+		"ControlType.POSITIVE": "positive",
+		"ControlType.ACCENT": "accent"
+	};
+	return enumMapping[strippedValue] || strippedValue;
 };
-var button_default = transformer;
-export {
-  button_default as default,
-  parser
+/**
+* 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 reporter = createReporter(j, manualReviewIssues);
+	const { exists: hasButtonImport } = hasImport(root, "@transferwise/components", "Button", j);
+	const { exists: hasActionButtonImport, remove: removeActionButtonImport } = hasImport(root, "@transferwise/components", "ActionButton", j);
+	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) {
+		root.findJSXElements("ActionButton").forEach((path) => {
+			const { openingElement, closingElement } = path.node;
+			openingElement.name = setNameIfJSXIdentifier(openingElement.name, "Button");
+			if (closingElement) closingElement.name = setNameIfJSXIdentifier(closingElement.name, "Button");
+			addAttributesIfMissing(j, openingElement, [{
+				attribute: j.jsxAttribute(j.jsxIdentifier("v2")),
+				name: "v2"
+			}, {
+				attribute: j.jsxAttribute(j.jsxIdentifier("size"), j.literal("sm")),
+				name: "size"
+			}]);
+			processIconChildren(j, path.node.children, iconImports, openingElement);
+			if ((openingElement.attributes ?? []).some((attr) => attr.type === "JSXSpreadAttribute")) reporter.reportSpreadProps(path);
+			const legacyPropNames = ["priority", "text"];
+			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") reporter.reportAttribute(attr, path);
+						}
+					}
+				}
+			});
+			const hasTextProp = openingElement.attributes?.some((attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === "text");
+			const hasChildren = path.node.children?.some((child) => child.type === "JSXText" && child.value.trim() !== "" || child.type === "JSXElement" || child.type === "JSXExpressionContainer");
+			if (hasTextProp && hasChildren) reporter.reportPropWithChildren(path, "text");
+			(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) root.findJSXElements("Button").forEach((path) => {
+		const { openingElement } = path.node;
+		if (hasAttributeOnElement(openingElement, "v2")) return;
+		addAttributesIfMissing(j, openingElement, [{
+			attribute: j.jsxAttribute(j.jsxIdentifier("v2")),
+			name: "v2"
+		}]);
+		processIconChildren(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] = convertEnumValue(String(j(attr.value.expression).toSource()));
+				} else legacyProps[name] = void 0;
+			}
+		});
+		if (openingElement.attributes) openingElement.attributes = openingElement.attributes.filter((attr) => !(attr.type === "JSXAttribute" && attr.name && legacyPropNames.includes(attr.name.name)));
+		if ("size" in legacyProps) {
+			const rawValue = legacyProps.size;
+			const resolved = resolveSize(rawValue);
+			const supportedSizes = [
+				"xs",
+				"sm",
+				"md",
+				"lg",
+				"xl"
+			];
+			if (typeof rawValue === "string" && typeof resolved === "string" && supportedSizes.includes(resolved)) 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;
+			const converted = convertEnumValue(rawValue);
+			const mapped = resolvePriority(legacyProps.type, converted);
+			const supportedPriorities = [
+				"primary",
+				"secondary",
+				"tertiary",
+				"secondary-neutral"
+			];
+			if (typeof rawValue === "string" && typeof mapped === "string" && supportedPriorities.includes(mapped)) 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;
+			const resolvedType = typeof rawType === "string" ? rawType : rawType && typeof rawType === "object" ? convertEnumValue(j(rawType).toSource()) : void 0;
+			const resolved = resolveType(resolvedType, rawHtmlType);
+			const supportedTypes = [
+				"accent",
+				"negative",
+				"positive",
+				"primary",
+				"pay",
+				"secondary",
+				"danger",
+				"link",
+				"submit",
+				"button",
+				"reset"
+			];
+			if (typeof resolved === "string" && supportedTypes.includes(resolved)) {
+				openingElement.attributes?.push(j.jsxAttribute(j.jsxIdentifier("type"), j.literal(resolved)));
+				if (resolved === "negative") openingElement.attributes?.push(j.jsxAttribute(j.jsxIdentifier("sentiment"), j.literal("negative")));
+			} else if (typeof rawType === "string" || typeof rawHtmlType === "string") reporter.reportUnsupportedValue(path, "type", rawType ?? rawHtmlType ?? "");
+			else if (rawType !== void 0 || rawHtmlType !== void 0) reporter.reportAmbiguousExpression(path, "type");
+		}
+		if ("sentiment" in legacyProps) {
+			const rawValue = legacyProps.sentiment;
+			if (rawValue === "negative") 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 && asValue !== "a") reporter.reportUnsupportedValue(path, "as", asValue);
+		if (asValue === "a") {
+			if (asIndex !== -1) openingElement.attributes = openingElement.attributes?.filter((_, 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_reportManualReview.reportManualReview(file.path, issue);
+	});
+	return root.toSource();
 };
+
+//#endregion
+exports.default = transformer;
+exports.parser = parser;
 //# sourceMappingURL=button.js.map