@mmapp/react-compiler 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/chunk-WVYY32LD.mjs

@@ -1,939 +0,0 @@
-// src/codemod/index.ts
-import { transformSync } from "@babel/core";
-import { declare } from "@babel/helper-plugin-utils";
-
-// src/codemod/forward.ts
-import * as t2 from "@babel/types";
-
-// src/codemod/rules.ts
-var FORWARD_RULES = [
-  // div with flex-col → Stack
-  {
-    htmlTag: "div",
-    atom: "Stack",
-    classSignal: ["flex-col"],
-    implicitClasses: ["flex", "flex-col"],
-    priority: 20
-  },
-  // div with grid → Grid
-  {
-    htmlTag: "div",
-    atom: "Grid",
-    classSignal: ["grid"],
-    implicitClasses: ["grid"],
-    priority: 20
-  },
-  // div with flex (no flex-col) → Row
-  {
-    htmlTag: "div",
-    atom: "Row",
-    classSignal: ["flex"],
-    implicitClasses: ["flex"],
-    priority: 10
-  },
-  // div with no layout signal → Stack (default container)
-  {
-    htmlTag: "div",
-    atom: "Stack",
-    classSignal: [],
-    implicitClasses: [],
-    priority: 0
-  },
-  // Semantic HTML
-  { htmlTag: "main", atom: "Stack", implicitClasses: [] },
-  { htmlTag: "aside", atom: "Stack", implicitClasses: [] },
-  { htmlTag: "nav", atom: "Stack", implicitClasses: [] },
-  { htmlTag: "section", atom: "Section", implicitClasses: [] },
-  { htmlTag: "header", atom: "Row", implicitClasses: [] },
-  { htmlTag: "footer", atom: "Row", implicitClasses: [] },
-  // Text elements
-  { htmlTag: "span", atom: "Text", implicitClasses: [] },
-  { htmlTag: "p", atom: "Text", implicitClasses: [] },
-  { htmlTag: "label", atom: "Text", implicitClasses: [] },
-  { htmlTag: "h1", atom: "Text", implicitClasses: [], props: { variant: "h1" } },
-  { htmlTag: "h2", atom: "Text", implicitClasses: [], props: { variant: "h2" } },
-  { htmlTag: "h3", atom: "Text", implicitClasses: [], props: { variant: "h3" } },
-  { htmlTag: "h4", atom: "Text", implicitClasses: [], props: { variant: "h4" } },
-  { htmlTag: "h5", atom: "Text", implicitClasses: [], props: { variant: "h5" } },
-  { htmlTag: "h6", atom: "Text", implicitClasses: [], props: { variant: "h6" } },
-  // Interactive elements
-  { htmlTag: "button", atom: "Button", implicitClasses: [] },
-  { htmlTag: "a", atom: "Link", implicitClasses: [] },
-  // Form elements
-  { htmlTag: "input", atom: "TextInput", implicitClasses: [] },
-  {
-    htmlTag: "textarea",
-    atom: "TextInput",
-    implicitClasses: [],
-    props: { multiline: true }
-  },
-  // Media
-  { htmlTag: "img", atom: "Image", implicitClasses: [] }
-];
-var REVERSE_RULES = [
-  { atom: "Stack", htmlTag: "div", injectClasses: ["flex", "flex-col"] },
-  { atom: "Row", htmlTag: "div", injectClasses: ["flex"] },
-  { atom: "Grid", htmlTag: "div", injectClasses: ["grid"] },
-  { atom: "Text", htmlTag: "span" },
-  { atom: "Button", htmlTag: "button" },
-  { atom: "Link", htmlTag: "a" },
-  { atom: "TextInput", htmlTag: "input" },
-  { atom: "Image", htmlTag: "img" },
-  { atom: "Section", htmlTag: "section" }
-];
-var CONTROL_FLOW_ATOMS = /* @__PURE__ */ new Set([
-  "Show",
-  "Each",
-  "Modal",
-  "Slot",
-  "Divider"
-]);
-var ATOM_IMPORT_SOURCE = "@mmapp/react/atoms";
-var TEXT_VARIANT_TO_TAG = {
-  h1: "h1",
-  h2: "h2",
-  h3: "h3",
-  h4: "h4",
-  h5: "h5",
-  h6: "h6"
-};
-
-// src/codemod/classify.ts
-function extractStaticClasses(attrValue) {
-  if (!attrValue) return [];
-  if (attrValue.type === "StringLiteral") {
-    return attrValue.value.split(/\s+/).filter(Boolean);
-  }
-  if (attrValue.type === "JSXExpressionContainer") {
-    return extractStaticClasses(attrValue.expression);
-  }
-  if (attrValue.type === "TemplateLiteral") {
-    const staticParts = attrValue.quasis.map((q) => q.value.raw).join(" ");
-    return staticParts.split(/\s+/).filter(Boolean);
-  }
-  if (attrValue.type === "CallExpression" && attrValue.callee.type === "Identifier" && attrValue.callee.name === "cn" && attrValue.arguments.length > 0) {
-    const firstArg = attrValue.arguments[0];
-    if (firstArg.type === "StringLiteral") {
-      return firstArg.value.split(/\s+/).filter(Boolean);
-    }
-  }
-  return [];
-}
-function classifyElement(tagName, classNames) {
-  if (tagName[0] === tagName[0].toUpperCase() && tagName[0] !== tagName[0].toLowerCase()) {
-    return null;
-  }
-  if (tagName.startsWith("motion.")) {
-    return null;
-  }
-  const candidates = FORWARD_RULES.filter((r) => r.htmlTag === tagName).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
-  if (candidates.length === 0) return null;
-  if (tagName === "div") {
-    for (const rule2 of candidates) {
-      if (!rule2.classSignal || rule2.classSignal.length === 0) {
-        continue;
-      }
-      const hasAllSignals = rule2.classSignal.every((s) => classNames.includes(s));
-      if (hasAllSignals) {
-        return makeResult(rule2, tagName);
-      }
-    }
-    const defaultRule = candidates.find((r) => (r.priority ?? 0) === 0);
-    if (defaultRule) {
-      return makeResult(defaultRule, tagName);
-    }
-  }
-  const rule = candidates[0];
-  return makeResult(rule, tagName);
-}
-function makeResult(rule, tagName) {
-  return {
-    atom: rule.atom,
-    removeClasses: rule.implicitClasses ?? [],
-    addProps: rule.props ?? {},
-    originalTag: tagName
-  };
-}
-function reverseClassifyAtom(atomName, props) {
-  if (CONTROL_FLOW_ATOMS.has(atomName)) return null;
-  if (atomName === "Text") {
-    const variantNode = props.get("variant");
-    if (variantNode && variantNode.type === "StringLiteral") {
-      const tag = TEXT_VARIANT_TO_TAG[variantNode.value];
-      if (tag) {
-        return {
-          htmlTag: tag,
-          injectClasses: [],
-          removeProps: ["variant"]
-        };
-      }
-    }
-    return { htmlTag: "span", injectClasses: [], removeProps: [] };
-  }
-  if (atomName === "TextInput") {
-    const multilineNode = props.get("multiline");
-    if (multilineNode) {
-      const isMultiline = multilineNode.type === "BooleanLiteral" && multilineNode.value || multilineNode.type === "JSXExpressionContainer" && multilineNode.expression?.type === "BooleanLiteral" && multilineNode.expression?.value;
-      if (isMultiline) {
-        return { htmlTag: "textarea", injectClasses: [], removeProps: ["multiline"] };
-      }
-    }
-    return { htmlTag: "input", injectClasses: [], removeProps: [] };
-  }
-  const rule = REVERSE_RULES.find((r) => r.atom === atomName);
-  if (!rule) return null;
-  return {
-    htmlTag: rule.htmlTag,
-    injectClasses: rule.injectClasses ?? [],
-    removeProps: rule.removeProps ?? []
-  };
-}
-function removeClassesFromString(className, toRemove) {
-  if (toRemove.length === 0) return className;
-  const removeSet = new Set(toRemove);
-  return className.split(/\s+/).filter((c) => c && !removeSet.has(c)).join(" ");
-}
-function addClassesToString(className, toAdd) {
-  if (toAdd.length === 0) return className;
-  const existing = new Set(className.split(/\s+/).filter(Boolean));
-  const newClasses = toAdd.filter((c) => !existing.has(c));
-  if (newClasses.length === 0) return className;
-  return [...newClasses, ...className.split(/\s+/).filter(Boolean)].join(" ");
-}
-
-// src/codemod/control-flow.ts
-import * as t from "@babel/types";
-function matchConditionalRender(expr) {
-  if (expr.type !== "LogicalExpression" || expr.operator !== "&&") return null;
-  if (!isJSXLike(expr.right)) return null;
-  return { condition: expr.left, consequent: expr.right };
-}
-function matchTernaryRender(expr) {
-  if (expr.type !== "ConditionalExpression") return null;
-  if (!isJSXLike(expr.consequent) && !isJSXLike(expr.alternate)) return null;
-  return {
-    condition: expr.test,
-    consequent: expr.consequent,
-    alternate: expr.alternate
-  };
-}
-function matchMapRender(expr) {
-  if (expr.type !== "CallExpression") return null;
-  if (expr.callee.type !== "MemberExpression") return null;
-  const prop = expr.callee.property;
-  if (!(prop.type === "Identifier" && prop.name === "map")) return null;
-  const array = expr.callee.object;
-  const callback = expr.arguments[0];
-  if (!callback) return null;
-  if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression")
-    return null;
-  const param = callback.params[0] || t.identifier("item");
-  const indexParam = callback.params[1] && callback.params[1].type === "Identifier" ? callback.params[1] : null;
-  let keyExpression = null;
-  const returnedJSX = getReturnedJSX(callback.body);
-  if (returnedJSX && returnedJSX.type === "JSXElement") {
-    const keyAttr = returnedJSX.openingElement.attributes.find(
-      (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "key"
-    );
-    if (keyAttr && keyAttr.value) {
-      if (keyAttr.value.type === "JSXExpressionContainer") {
-        keyExpression = keyAttr.value.expression;
-      } else if (keyAttr.value.type === "StringLiteral") {
-        keyExpression = keyAttr.value;
-      }
-    }
-  }
-  return {
-    array,
-    param,
-    indexParam,
-    body: callback.body,
-    keyExpression
-  };
-}
-function createShowElement(condition, children) {
-  const whenAttr = t.jsxAttribute(
-    t.jsxIdentifier("when"),
-    t.jsxExpressionContainer(condition)
-  );
-  const childNodes = [];
-  if (t.isJSXElement(children) || t.isJSXFragment(children)) {
-    childNodes.push(children);
-  } else {
-    childNodes.push(t.jsxExpressionContainer(children));
-  }
-  return t.jsxElement(
-    t.jsxOpeningElement(t.jsxIdentifier("Show"), [whenAttr]),
-    t.jsxClosingElement(t.jsxIdentifier("Show")),
-    childNodes,
-    false
-  );
-}
-function createEachElement(items, paramName, body, keyExpression, indexParam) {
-  const attrs = [
-    t.jsxAttribute(
-      t.jsxIdentifier("items"),
-      t.jsxExpressionContainer(items)
-    ),
-    t.jsxAttribute(t.jsxIdentifier("as"), t.stringLiteral(paramName))
-  ];
-  if (keyExpression) {
-    attrs.push(
-      t.jsxAttribute(
-        t.jsxIdentifier("keyField"),
-        t.jsxExpressionContainer(keyExpression)
-      )
-    );
-  }
-  const params = [t.identifier(paramName)];
-  if (indexParam) params.push(indexParam);
-  const arrow = t.arrowFunctionExpression(params, body);
-  const child = t.jsxExpressionContainer(arrow);
-  removeKeyFromBody(body);
-  return t.jsxElement(
-    t.jsxOpeningElement(t.jsxIdentifier("Each"), attrs),
-    t.jsxClosingElement(t.jsxIdentifier("Each")),
-    [child],
-    false
-  );
-}
-function matchShowElement(node) {
-  const tag = node.openingElement.name;
-  if (tag.type !== "JSXIdentifier" || tag.name !== "Show") return null;
-  const whenAttr = node.openingElement.attributes.find(
-    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "when"
-  );
-  if (!whenAttr || !whenAttr.value) return null;
-  let condition;
-  if (whenAttr.value.type === "JSXExpressionContainer") {
-    condition = whenAttr.value.expression;
-  } else if (whenAttr.value.type === "StringLiteral") {
-    condition = whenAttr.value;
-  } else {
-    return null;
-  }
-  return { condition, children: node.children };
-}
-function matchEachElement(node) {
-  const tag = node.openingElement.name;
-  if (tag.type !== "JSXIdentifier" || tag.name !== "Each") return null;
-  const itemsAttr = node.openingElement.attributes.find(
-    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "items"
-  );
-  if (!itemsAttr?.value) return null;
-  const asAttr = node.openingElement.attributes.find(
-    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "as"
-  );
-  const keyAttr = node.openingElement.attributes.find(
-    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "keyField"
-  );
-  let items;
-  if (itemsAttr.value.type === "JSXExpressionContainer") {
-    items = itemsAttr.value.expression;
-  } else {
-    return null;
-  }
-  const paramName = asAttr?.value?.type === "StringLiteral" ? asAttr.value.value : "item";
-  let keyExpression = null;
-  if (keyAttr?.value?.type === "JSXExpressionContainer") {
-    keyExpression = keyAttr.value.expression;
-  }
-  return { items, paramName, keyExpression, children: node.children };
-}
-function showToConditional(condition, children) {
-  const content = unwrapChildren(children);
-  const logical = t.logicalExpression("&&", condition, content);
-  return t.jsxExpressionContainer(logical);
-}
-function eachToMap(items, paramName, keyExpression, children) {
-  let callback = null;
-  for (const child of children) {
-    if (child.type === "JSXExpressionContainer" && child.expression.type !== "JSXEmptyExpression") {
-      const expr = child.expression;
-      if (expr.type === "ArrowFunctionExpression" || expr.type === "FunctionExpression") {
-        callback = expr;
-        break;
-      }
-    }
-  }
-  if (!callback) {
-    const content = unwrapChildren(children);
-    callback = t.arrowFunctionExpression([t.identifier(paramName)], content);
-  }
-  if (keyExpression) {
-    addKeyToCallback(callback, keyExpression);
-  }
-  const mapCall = t.callExpression(
-    t.memberExpression(items, t.identifier("map")),
-    [callback]
-  );
-  return t.jsxExpressionContainer(mapCall);
-}
-function isJSXLike(node) {
-  return node.type === "JSXElement" || node.type === "JSXFragment" || node.type === "ParenthesizedExpression" && isJSXLike(node.expression);
-}
-function getReturnedJSX(body) {
-  if (body.type === "JSXElement" || body.type === "JSXFragment") return body;
-  if (body.type === "ParenthesizedExpression") {
-    return getReturnedJSX(body.expression);
-  }
-  if (body.type === "BlockStatement") {
-    for (const stmt of body.body) {
-      if (stmt.type === "ReturnStatement" && stmt.argument) {
-        if (stmt.argument.type === "JSXElement" || stmt.argument.type === "JSXFragment") {
-          return stmt.argument;
-        }
-        if (stmt.argument.type === "ParenthesizedExpression") {
-          return getReturnedJSX(stmt.argument.expression);
-        }
-      }
-    }
-  }
-  return null;
-}
-function removeKeyFromBody(body) {
-  const jsx = getReturnedJSX(body);
-  if (jsx && jsx.type === "JSXElement") {
-    jsx.openingElement.attributes = jsx.openingElement.attributes.filter(
-      (a) => !(a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "key")
-    );
-  }
-}
-function addKeyToCallback(callback, keyExpr) {
-  const jsx = getReturnedJSX(callback.body);
-  if (jsx && jsx.type === "JSXElement") {
-    const hasKey = jsx.openingElement.attributes.some(
-      (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "key"
-    );
-    if (!hasKey) {
-      jsx.openingElement.attributes.unshift(
-        t.jsxAttribute(
-          t.jsxIdentifier("key"),
-          t.jsxExpressionContainer(keyExpr)
-        )
-      );
-    }
-  }
-}
-function unwrapChildren(children) {
-  const meaningful = children.filter((c) => {
-    if (c.type === "JSXText") return c.value.trim().length > 0;
-    return true;
-  });
-  if (meaningful.length === 1) {
-    const child = meaningful[0];
-    if (child.type === "JSXElement" || child.type === "JSXFragment") return child;
-    if (child.type === "JSXExpressionContainer") {
-      return child.expression;
-    }
-  }
-  return t.jsxFragment(t.jsxOpeningFragment(), t.jsxClosingFragment(), meaningful);
-}
-
-// src/codemod/annotation.ts
-var ANNOTATION_PREFIX = "@mm-original";
-function createAnnotation(originalTag, classNames) {
-  const parts = [originalTag, ...classNames.slice(0, 10)];
-  return `${ANNOTATION_PREFIX} ${parts.join(".")}`;
-}
-function parseAnnotation(comment) {
-  const trimmed = comment.trim();
-  if (!trimmed.startsWith(ANNOTATION_PREFIX)) return null;
-  const rest = trimmed.slice(ANNOTATION_PREFIX.length).trim();
-  if (!rest) return null;
-  const parts = rest.split(".");
-  const tag = parts[0];
-  const classes = parts.slice(1);
-  return { tag, classes };
-}
-function addAnnotationComment(node, originalTag, classNames) {
-  const text = ` ${createAnnotation(originalTag, classNames)} `;
-  if (!node.leadingComments) {
-    node.leadingComments = [];
-  }
-  node.leadingComments.push({
-    type: "CommentBlock",
-    value: text
-  });
-}
-function readAnnotationComment(node) {
-  if (!node.leadingComments) return null;
-  for (let i = node.leadingComments.length - 1; i >= 0; i--) {
-    const comment = node.leadingComments[i];
-    const parsed = parseAnnotation(comment.value);
-    if (parsed) {
-      node.leadingComments.splice(i, 1);
-      return parsed;
-    }
-  }
-  return null;
-}
-
-// src/codemod/forward.ts
-function createForwardVisitor(imports, options = {}) {
-  const { annotate = true } = options;
-  return {
-    JSXElement(path) {
-      const opening = path.node.openingElement;
-      const tag = opening.name;
-      if (tag.type !== "JSXIdentifier") return;
-      const tagName = tag.name;
-      const classAttr = opening.attributes.find(
-        (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "className"
-      );
-      const staticClasses = extractStaticClasses(classAttr?.value ?? null);
-      const result = classifyElement(tagName, staticClasses);
-      if (!result) return;
-      if (annotate) {
-        addAnnotationComment(path.node, result.originalTag, staticClasses);
-      }
-      tag.name = result.atom;
-      if (path.node.closingElement) {
-        path.node.closingElement.name.name = result.atom;
-      }
-      imports.addAtom(result.atom);
-      if (classAttr && result.removeClasses.length > 0) {
-        updateClassName(classAttr, result.removeClasses, "remove");
-      }
-      for (const [key, value] of Object.entries(result.addProps)) {
-        const existing = opening.attributes.find(
-          (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === key
-        );
-        if (!existing) {
-          if (typeof value === "boolean") {
-            opening.attributes.push(
-              t2.jsxAttribute(
-                t2.jsxIdentifier(key),
-                value ? null : t2.jsxExpressionContainer(t2.booleanLiteral(false))
-              )
-            );
-          } else {
-            opening.attributes.push(
-              t2.jsxAttribute(t2.jsxIdentifier(key), t2.stringLiteral(value))
-            );
-          }
-        }
-      }
-      renameEventHandlers(opening, "forward");
-    },
-    JSXExpressionContainer(path) {
-      if (!path.parentPath.isJSXElement() && !path.parentPath.isJSXFragment()) return;
-      const expr = path.node.expression;
-      if (expr.type === "JSXEmptyExpression") return;
-      const conditional = matchConditionalRender(expr);
-      if (conditional) {
-        const showEl = createShowElement(conditional.condition, conditional.consequent);
-        imports.addAtom("Show");
-        path.replaceWith(showEl);
-        return;
-      }
-      const ternary = matchTernaryRender(expr);
-      if (ternary) {
-        const show1 = createShowElement(ternary.condition, ternary.consequent);
-        const negated = t2.unaryExpression("!", ternary.condition);
-        const show2 = createShowElement(negated, ternary.alternate);
-        imports.addAtom("Show");
-        path.replaceWithMultiple([show1, show2]);
-        return;
-      }
-      const mapRender = matchMapRender(expr);
-      if (mapRender) {
-        const paramName = mapRender.param.type === "Identifier" ? mapRender.param.name : "item";
-        const eachEl = createEachElement(
-          mapRender.array,
-          paramName,
-          mapRender.body,
-          mapRender.keyExpression,
-          mapRender.indexParam
-        );
-        imports.addAtom("Each");
-        path.replaceWith(eachEl);
-        return;
-      }
-    }
-  };
-}
-function updateClassName(attr, classes, operation) {
-  if (!attr.value) return;
-  if (attr.value.type === "StringLiteral") {
-    const result = operation === "remove" ? removeClassesFromString(attr.value.value, classes) : attr.value.value;
-    if (result.trim()) {
-      attr.value = t2.stringLiteral(result);
-    } else {
-      attr.value = t2.stringLiteral("");
-    }
-    return;
-  }
-  if (attr.value.type === "JSXExpressionContainer") {
-    const expr = attr.value.expression;
-    if (expr.type === "TemplateLiteral") {
-      for (const quasi of expr.quasis) {
-        if (operation === "remove") {
-          quasi.value.raw = removeClassesFromString(quasi.value.raw, classes);
-          quasi.value.cooked = removeClassesFromString(quasi.value.cooked ?? quasi.value.raw, classes);
-        }
-      }
-      return;
-    }
-    if (expr.type === "CallExpression" && expr.callee.type === "Identifier" && expr.callee.name === "cn" && expr.arguments.length > 0) {
-      const firstArg = expr.arguments[0];
-      if (firstArg.type === "StringLiteral" && operation === "remove") {
-        firstArg.value = removeClassesFromString(firstArg.value, classes);
-      }
-      return;
-    }
-  }
-}
-function renameEventHandlers(opening, direction) {
-  const map = direction === "forward" ? { onClick: "onPress", onChange: "onChange", onSubmit: "onSubmit" } : { onPress: "onClick" };
-  for (const attr of opening.attributes) {
-    if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name in map) {
-      attr.name.name = map[attr.name.name];
-    }
-  }
-}
-
-// src/codemod/reverse.ts
-import * as t3 from "@babel/types";
-function createReverseVisitor(imports, _options = {}) {
-  return {
-    JSXElement: {
-      // Use exit so children are processed first (bottom-up)
-      exit(path) {
-        const opening = path.node.openingElement;
-        const tag = opening.name;
-        if (tag.type !== "JSXIdentifier") return;
-        const atomName = tag.name;
-        const showMatch = matchShowElement(path.node);
-        if (showMatch) {
-          const replacement = showToConditional(showMatch.condition, showMatch.children);
-          imports.removeAtom("Show");
-          path.replaceWith(replacement);
-          return;
-        }
-        const eachMatch = matchEachElement(path.node);
-        if (eachMatch) {
-          const replacement = eachToMap(
-            eachMatch.items,
-            eachMatch.paramName,
-            eachMatch.keyExpression,
-            eachMatch.children
-          );
-          imports.removeAtom("Each");
-          path.replaceWith(replacement);
-          return;
-        }
-        const annotation = readAnnotationComment(path.node);
-        const propsMap = /* @__PURE__ */ new Map();
-        for (const attr of opening.attributes) {
-          if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier") {
-            propsMap.set(attr.name.name, attr.value ?? t3.booleanLiteral(true));
-          }
-        }
-        const result = reverseClassifyAtom(atomName, propsMap);
-        if (!result) return;
-        const targetTag = annotation?.tag ?? result.htmlTag;
-        tag.name = targetTag;
-        if (path.node.closingElement) {
-          path.node.closingElement.name.name = targetTag;
-        }
-        imports.removeAtom(atomName);
-        if (result.removeProps.length > 0) {
-          opening.attributes = opening.attributes.filter(
-            (attr) => !(attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && result.removeProps.includes(attr.name.name))
-          );
-        }
-        if (result.injectClasses.length > 0) {
-          injectClasses(opening, result.injectClasses, annotation?.classes);
-        }
-        renameEventHandlers2(opening);
-      }
-    }
-  };
-}
-function injectClasses(opening, injectClasses2, _annotationClasses) {
-  const classAttr = opening.attributes.find(
-    (a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === "className"
-  );
-  if (classAttr && classAttr.value) {
-    if (classAttr.value.type === "StringLiteral") {
-      classAttr.value = t3.stringLiteral(
-        addClassesToString(classAttr.value.value, injectClasses2)
-      );
-      return;
-    }
-    if (classAttr.value.type === "JSXExpressionContainer") {
-      const expr = classAttr.value.expression;
-      if (expr.type === "TemplateLiteral" && expr.quasis.length > 0) {
-        const first = expr.quasis[0];
-        first.value.raw = addClassesToString(first.value.raw, injectClasses2);
-        first.value.cooked = addClassesToString(first.value.cooked ?? first.value.raw, injectClasses2);
-        return;
-      }
-      if (expr.type === "CallExpression" && expr.callee.type === "Identifier" && expr.callee.name === "cn" && expr.arguments.length > 0 && expr.arguments[0].type === "StringLiteral") {
-        expr.arguments[0] = t3.stringLiteral(
-          addClassesToString(expr.arguments[0].value, injectClasses2)
-        );
-        return;
-      }
-    }
-  } else {
-    const classValue = injectClasses2.join(" ");
-    if (classValue) {
-      opening.attributes.push(
-        t3.jsxAttribute(
-          t3.jsxIdentifier("className"),
-          t3.stringLiteral(classValue)
-        )
-      );
-    }
-  }
-}
-function renameEventHandlers2(opening) {
-  const map = { onPress: "onClick" };
-  for (const attr of opening.attributes) {
-    if (attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name in map) {
-      attr.name.name = map[attr.name.name];
-    }
-  }
-}
-
-// src/codemod/state-transform.ts
-import * as t4 from "@babel/types";
-function createStateVisitor(mode) {
-  if (mode === "preserve") return {};
-  if (mode === "annotate") {
-    return {
-      VariableDeclaration(path) {
-        for (const decl of path.node.declarations) {
-          if (!isUseStateCall(decl.init)) continue;
-          if (hasFieldAnnotation(path.node)) continue;
-          const fieldType = inferFieldType(decl.init);
-          const comment = ` @mm-field type=${fieldType} `;
-          if (!path.node.trailingComments) {
-            path.node.trailingComments = [];
-          }
-          path.node.trailingComments.push({
-            type: "CommentLine",
-            value: comment
-          });
-        }
-      }
-    };
-  }
-  return {
-    VariableDeclaration(path) {
-      for (const decl of path.node.declarations) {
-        if (!isUseStateCall(decl.init)) continue;
-        const migrateAnnotation = getMigrateAnnotation(path.node);
-        if (!migrateAnnotation) continue;
-        if (migrateAnnotation.type === "query") {
-          if (decl.id.type !== "ArrayPattern" || decl.id.elements.length < 1)
-            continue;
-          const nameNode = decl.id.elements[0];
-          if (!nameNode || nameNode.type !== "Identifier") continue;
-          decl.id = nameNode;
-          decl.init = t4.callExpression(t4.identifier("useQuery"), [
-            t4.stringLiteral(migrateAnnotation.model || nameNode.name),
-            t4.objectExpression([
-              t4.objectProperty(
-                t4.identifier("where"),
-                t4.objectExpression([])
-              )
-            ])
-          ]);
-        }
-      }
-    }
-  };
-}
-function isUseStateCall(node) {
-  return !!node && node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "useState";
-}
-function hasFieldAnnotation(node) {
-  return !!node.trailingComments && node.trailingComments.some((c) => c.value.includes("@mm-field"));
-}
-function inferFieldType(call) {
-  if (call.arguments.length === 0) return "any";
-  const arg = call.arguments[0];
-  if (arg.type === "StringLiteral") return "text";
-  if (arg.type === "NumericLiteral") return "number";
-  if (arg.type === "BooleanLiteral") return "boolean";
-  if (arg.type === "ArrayExpression") return "list";
-  if (arg.type === "ObjectExpression") return "object";
-  if (arg.type === "NullLiteral") return "any";
-  return "any";
-}
-function getMigrateAnnotation(node) {
-  const comments = [
-    ...node.leadingComments || [],
-    ...node.trailingComments || []
-  ];
-  for (const c of comments) {
-    const match = c.value.match(/@mm-migrate:\s*(query|mutation)(?:\s+(\w+))?/);
-    if (match) {
-      return {
-        type: match[1],
-        model: match[2]
-      };
-    }
-  }
-  return null;
-}
-
-// src/codemod/import-manager.ts
-import * as t5 from "@babel/types";
-function createImportTracker() {
-  const used = /* @__PURE__ */ new Set();
-  const removed = /* @__PURE__ */ new Set();
-  return {
-    addAtom(name) {
-      used.add(name);
-      removed.delete(name);
-    },
-    removeAtom(name) {
-      removed.add(name);
-    },
-    getUsedAtoms() {
-      return used;
-    },
-    getRemovedAtoms() {
-      return removed;
-    }
-  };
-}
-function rewriteImportsForward(programPath, tracker) {
-  const usedAtoms = tracker.getUsedAtoms();
-  if (usedAtoms.size === 0) return;
-  let existingImport = null;
-  programPath.traverse({
-    ImportDeclaration(path) {
-      if (path.node.source.value === ATOM_IMPORT_SOURCE) {
-        existingImport = path;
-      }
-    }
-  });
-  if (existingImport) {
-    const existing = new Set(
-      existingImport.node.specifiers.filter((s) => s.type === "ImportSpecifier").map((s) => s.imported.name)
-    );
-    for (const atom of usedAtoms) {
-      if (!existing.has(atom)) {
-        existingImport.node.specifiers.push(
-          t5.importSpecifier(t5.identifier(atom), t5.identifier(atom))
-        );
-      }
-    }
-  } else {
-    const specifiers = Array.from(usedAtoms).sort().map((name) => t5.importSpecifier(t5.identifier(name), t5.identifier(name)));
-    const importDecl = t5.importDeclaration(
-      specifiers,
-      t5.stringLiteral(ATOM_IMPORT_SOURCE)
-    );
-    const lastImport = programPath.get("body").filter((p) => p.isImportDeclaration()).pop();
-    if (lastImport) {
-      lastImport.insertAfter(importDecl);
-    } else {
-      programPath.get("body")[0].insertBefore(importDecl);
-    }
-  }
-}
-function rewriteImportsReverse(programPath, tracker) {
-  const removed = tracker.getRemovedAtoms();
-  if (removed.size === 0) return;
-  programPath.traverse({
-    ImportDeclaration(path) {
-      if (path.node.source.value !== ATOM_IMPORT_SOURCE) return;
-      path.node.specifiers = path.node.specifiers.filter((spec) => {
-        if (spec.type !== "ImportSpecifier") return true;
-        const name = spec.imported.name;
-        return !removed.has(name);
-      });
-      if (path.node.specifiers.length === 0) {
-        path.remove();
-      }
-    }
-  });
-  let hasReactImport = false;
-  programPath.traverse({
-    ImportDeclaration(path) {
-      if (path.node.source.value === "react") {
-        hasReactImport = true;
-      }
-    }
-  });
-  if (!hasReactImport) {
-    const reactImport = t5.importDeclaration(
-      [t5.importDefaultSpecifier(t5.identifier("React"))],
-      t5.stringLiteral("react")
-    );
-    programPath.get("body")[0].insertBefore(reactImport);
-  }
-}
-
-// src/codemod/index.ts
-var codemodPlugin = declare(
-  (api, options) => {
-    api.assertVersion(7);
-    const direction = options.direction || "forward";
-    const stateMode = options.stateMode || "preserve";
-    return {
-      name: "mm-codemod",
-      visitor: {
-        Program: {
-          enter(programPath) {
-            const imports = createImportTracker();
-            const stateVisitor = createStateVisitor(stateMode);
-            if (direction === "forward") {
-              const forwardVisitor = createForwardVisitor(imports, {
-                annotate: options.annotate ?? true,
-                stateMode
-              });
-              programPath.traverse(stateVisitor);
-              programPath.traverse(forwardVisitor);
-              rewriteImportsForward(programPath, imports);
-            } else {
-              const reverseVisitor = createReverseVisitor(imports, {
-                stripAnnotations: !options.annotate
-              });
-              programPath.traverse(reverseVisitor);
-              rewriteImportsReverse(programPath, imports);
-            }
-          }
-        }
-      }
-    };
-  }
-);
-var codemod_default = codemodPlugin;
-function transform(source, options) {
-  const babelOptions = {
-    filename: "file.tsx",
-    plugins: [
-      ["@babel/plugin-syntax-typescript", { isTSX: true }],
-      [codemodPlugin, options]
-    ],
-    // Preserve formatting as much as possible
-    retainLines: true,
-    compact: false,
-    sourceMaps: true
-  };
-  const result = transformSync(source, babelOptions);
-  if (!result || !result.code) {
-    throw new Error("Codemod transform produced no output");
-  }
-  return { code: result.code, map: result.map };
-}
-
-export {
-  FORWARD_RULES,
-  REVERSE_RULES,
-  ATOM_IMPORT_SOURCE,
-  extractStaticClasses,
-  classifyElement,
-  reverseClassifyAtom,
-  createImportTracker,
-  codemodPlugin,
-  codemod_default,
-  transform
-};