@wise/wds-codemods 0.0.1-experimental-30f960e → 0.0.1-experimental-cc95209

package/dist/transforms/button.js

@@ -1,516 +1,606 @@
-Object.defineProperty(exports, '__esModule', { value: true });
-const require_reportManualReview = require('../reportManualReview-DQ00-OKx.js');
+// src/utils/reportManualReview.ts
+import fs from "node: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;
+
+// src/transforms/helpers/createTestTransform.ts
+import { applyTransform } from "jscodeshift/src/testUtils";
 
-//#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.
-*/
+// src/transforms/helpers/hasImport.ts
 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((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
-	};
+  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 };
 }
+var hasImport_default = hasImport;
 
-//#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);
+// 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);
+  }
 };
+var iconUtils_default = processIconChildren;
 
-//#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;
+// src/transforms/helpers/jsxElementUtils.ts
+var 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);
+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 JSX element's openingElement has a specific attribute.
-*/
-const hasAttributeOnElement = (element, attributeName) => {
-	return hasAttribute(element.attributes, attributeName);
+var 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);
-	});
+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);
+    }
+  });
 };
 
-//#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);
-* ```
-*/
+// src/transforms/helpers/jsxReportingUtils.ts
 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);
-		});
-	}
-	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);
+      }
+    });
+  }
+  // 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);
+  }
 };
-const createReporter = (j, issues) => {
-	return new CodemodReporter({
-		jscodeshift: j,
-		issues
-	});
+var createReporter = (j, issues) => {
+  return new CodemodReporter({ jscodeshift: j, issues });
 };
 
-//#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"
-	}
+// 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"
+  }
 };
-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 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;
+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 resolvePriority = (type, priority) => {
-	if (type && priority) return priorityMapping[type]?.[priority] || priority;
-	return priority;
+var resolvePriority = (type, priority) => {
+  if (type && priority) {
+    return priorityMapping[type]?.[priority] || priority;
+  }
+  return priority;
 };
-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 resolveType = (type, htmlType) => {
+  if (htmlType) {
+    return htmlType;
+  }
+  const legacyButtonTypes = [
+    "accent",
+    "negative",
+    "positive",
+    "primary",
+    "pay",
+    "secondary",
+    "danger",
+    "link",
+    "button",
+    "reset",
+    "submit"
+  ];
+  return type && legacyButtonTypes.includes(type) ? type : null;
 };
-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 convertEnumValue = (value) => {
+  if (!value) return { converted: value, wasEnum: false };
+  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",
+    "ControlType.BUTTON": "button",
+    "ControlType.RESET": "reset",
+    "HtmlType.SUBMIT": "submit",
+    "HtmlType.BUTTON": "button",
+    "HtmlType.RESET": "reset",
+    "Sentiment.NEGATIVE": "negative"
+  };
+  const wasEnum = strippedValue in enumMapping;
+  const converted = enumMapping[strippedValue] || strippedValue;
+  return { converted, wasEnum };
 };
-/**
-* 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();
+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"];
+      const keepAttributes = [];
+      (openingElement.attributes ?? []).forEach((attr) => {
+        if (attr.type === "JSXAttribute" && attr.name && attr.name.type === "JSXIdentifier" && legacyPropNames.includes(attr.name.name)) {
+          const { name } = attr.name;
+          let migrated = false;
+          let rawStringValue;
+          if (attr.value) {
+            if (attr.value.type === "StringLiteral") {
+              rawStringValue = attr.value.value;
+              legacyProps[name] = attr.value.value;
+            } else if (attr.value.type === "JSXExpressionContainer") {
+              rawStringValue = String(j(attr.value.expression).toSource());
+              const { converted } = convertEnumValue(rawStringValue);
+              legacyProps[name] = converted;
+            }
+          } else {
+            legacyProps[name] = void 0;
+          }
+          const { wasEnum } = convertEnumValue(rawStringValue);
+          if (rawStringValue && wasEnum) {
+            migrated = true;
+          } else if (name === "size") {
+            const rawValue = legacyProps.size;
+            const resolved2 = resolveSize(rawValue);
+            const supportedSizes = ["xs", "sm", "md", "lg", "xl"];
+            if (typeof rawValue === "string" && typeof resolved2 === "string" && supportedSizes.includes(resolved2)) {
+              migrated = true;
+            } else if (typeof rawValue === "string") {
+              reporter.reportUnsupportedValue(path2, "size", rawValue);
+            } else if (rawValue !== void 0) {
+              reporter.reportAmbiguousExpression(path2, "size");
+            }
+          } else if (name === "priority") {
+            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)) {
+              migrated = true;
+            } else if (typeof rawValue === "string") {
+              reporter.reportUnsupportedValue(path2, "priority", rawValue);
+            } else if (rawValue !== void 0) {
+              reporter.reportAmbiguousExpression(path2, "priority");
+            }
+          } else if (name === "type" || name === "htmlType") {
+            const rawType2 = legacyProps.type;
+            const rawHtmlType2 = legacyProps.htmlType;
+            const resolvedType2 = typeof rawType2 === "string" ? rawType2 : rawType2 && typeof rawType2 === "object" ? convertEnumValue(j(rawType2).toSource()).converted : void 0;
+            const resolved2 = resolveType(resolvedType2, rawHtmlType2);
+            const supportedTypes2 = ["button", "reset", "submit"];
+            if (typeof resolved2 === "string" && supportedTypes2.includes(resolved2)) {
+              migrated = true;
+            } else if (typeof rawType2 === "string" || typeof rawHtmlType2 === "string") {
+              reporter.reportUnsupportedValue(path2, "type", rawType2 ?? rawHtmlType2 ?? "");
+            } else if (rawType2 !== void 0 || rawHtmlType2 !== void 0) {
+              reporter.reportAmbiguousExpression(path2, "type");
+            }
+          } else if (name === "sentiment") {
+            const rawValue = legacyProps.sentiment;
+            if (rawValue === "negative") {
+              migrated = true;
+            } else if (typeof rawValue === "string") {
+              reporter.reportUnsupportedValue(path2, "sentiment", rawValue);
+            } else if (rawValue !== void 0) {
+              reporter.reportAmbiguousExpression(path2, "sentiment");
+            }
+          }
+          if (!migrated) keepAttributes.push(attr);
+        } else {
+          keepAttributes.push(attr);
+        }
+      });
+      const newAttributes = [];
+      const rawSize = legacyProps.size;
+      const resolvedSize = resolveSize(rawSize);
+      if (typeof rawSize === "string" && typeof resolvedSize === "string" && ["xs", "sm", "md", "lg", "xl"].includes(resolvedSize)) {
+        newAttributes.push(j.jsxAttribute(j.jsxIdentifier("size"), j.literal(resolvedSize)));
+      }
+      const rawPriority = legacyProps.priority;
+      const { converted: convertedPriority } = convertEnumValue(rawPriority);
+      const mappedPriority = resolvePriority(legacyProps.type, convertedPriority);
+      if (typeof rawPriority === "string" && typeof mappedPriority === "string" && ["primary", "secondary", "tertiary", "secondary-neutral"].includes(mappedPriority)) {
+        newAttributes.push(j.jsxAttribute(j.jsxIdentifier("priority"), j.literal(mappedPriority)));
+      }
+      const rawType = legacyProps.type;
+      const rawHtmlType = legacyProps.htmlType;
+      const resolvedType = typeof rawType === "string" ? rawType : rawType && typeof rawType === "object" ? convertEnumValue(j(rawType).toSource()).converted : void 0;
+      const resolved = resolveType(resolvedType, rawHtmlType);
+      const supportedTypes = ["button", "reset", "submit", "negative"];
+      if (typeof resolved === "string" && supportedTypes.includes(resolved)) {
+        if (resolved !== "negative") {
+          newAttributes.push(j.jsxAttribute(j.jsxIdentifier("type"), j.literal(resolved)));
+        }
+        if (resolved === "negative") {
+          newAttributes.push(j.jsxAttribute(j.jsxIdentifier("sentiment"), j.literal("negative")));
+        }
+      }
+      const rawSentiment = legacyProps.sentiment;
+      if (rawSentiment === "negative") {
+        newAttributes.push(j.jsxAttribute(j.jsxIdentifier("sentiment"), j.literal("negative")));
+      }
+      Array.prototype.push.apply(newAttributes, keepAttributes);
+      let asIndex = -1;
+      let asValue = null;
+      let hrefExists = false;
+      let asAmbiguous = false;
+      let hrefAmbiguous = false;
+      newAttributes.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) {
+          newAttributes.splice(asIndex, 1);
+        }
+        if (!hrefExists) {
+          newAttributes.push(j.jsxAttribute(j.jsxIdentifier("href"), j.literal("#")));
+        }
+      }
+      openingElement.attributes = newAttributes;
+      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();
+};
+var button_default = transformer;
+export {
+  button_default as default,
+  parser
 };
-
-//#endregion
-exports.default = transformer;
-exports.parser = parser;
 //# sourceMappingURL=button.js.map