@wise/wds-codemods 0.0.1-experimental-6c2101b

package/dist/transforms/button.js

@@ -0,0 +1,640 @@
+// 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/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((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;
+
+// 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;
+
+// src/transforms/helpers/jsxElementUtils.ts
+var 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
+  );
+};
+var 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);
+    }
+  });
+};
+
+// 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);
+      }
+    });
+  }
+  // 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);
+  }
+};
+var createReporter = (j, issues) => {
+  return new CodemodReporter({ jscodeshift: j, issues });
+};
+
+// src/transforms/helpers/packageValidation.ts
+function validatePackageRequirements(options, requirements) {
+  let packageResults = {};
+  if (options.packageResults) {
+    if (typeof options.packageResults === "string") {
+      try {
+        if (options.packageResults.trim() && options.packageResults.trim().startsWith("{")) {
+          packageResults = JSON.parse(options.packageResults);
+        }
+      } catch (error) {
+        console.debug("Failed to parse packageResults:", error);
+        return false;
+      }
+    } else if (typeof options.packageResults === "object") {
+      packageResults = options.packageResults;
+    }
+  }
+  const allRequirementsMet = requirements.every((req) => {
+    const key = `${req.name}@${req.version}`;
+    return packageResults[key];
+  });
+  if (!allRequirementsMet) {
+    const missing = requirements.filter((req) => {
+      const key = `${req.name}@${req.version}`;
+      return !packageResults[key];
+    });
+    const missingPackages = missing.map((pkg) => `${pkg.name}@${pkg.version}`).join(", ");
+    console.debug(`Skipping transform - missing required packages: ${missingPackages}`);
+  }
+  return allRequirementsMet;
+}
+
+// src/transforms/button/button.ts
+var parser = "tsx";
+var packageRequirements = [{ name: "@transferwise/components", version: ">=46.5.0" }];
+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"
+};
+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;
+};
+var resolvePriority = (type, priority) => {
+  if (type && priority) {
+    return priorityMapping[type]?.[priority] || priority;
+  }
+  return priority;
+};
+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;
+};
+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 };
+};
+var transformer = (file, api, options) => {
+  if (!validatePackageRequirements(options, packageRequirements)) {
+    return file.source;
+  }
+  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,
+  packageRequirements,
+  parser
+};
+//# sourceMappingURL=button.js.map