@mgcrea/react-native-tailwind 0.6.1 → 0.8.0

package/dist/babel/index.cjs

@@ -258,8 +258,8 @@ function parseBorderRadius(cls) {
   return null;
 }
 
-// src/config/palettes.ts
-var TAILWIND_PALETTES = {
+// src/config/tailwind.ts
+var TAILWIND_COLORS = {
   red: {
     "50": "#fef2f2",
     "100": "#ffe2e2",
@@ -548,20 +548,28 @@ var TAILWIND_PALETTES = {
   }
 };
 
-// src/parser/colors.ts
-function flattenColors() {
-  const flat = {};
-  for (const [colorName, shades] of Object.entries(TAILWIND_PALETTES)) {
-    for (const [shade, hex] of Object.entries(shades)) {
-      flat[`${colorName}-${shade}`] = hex;
+// src/utils/flattenColors.ts
+function flattenColors(colors, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(colors)) {
+    const newKey = prefix ? `${prefix}-${key}` : key;
+    if (typeof value === "string") {
+      result[newKey] = value;
+    } else if (typeof value === "object" && value !== null) {
+      Object.assign(result, flattenColors(value, newKey));
     }
   }
-  flat.white = "#FFFFFF";
-  flat.black = "#000000";
-  flat.transparent = "transparent";
-  return flat;
+  return result;
 }
-var COLORS = flattenColors();
+
+// src/parser/colors.ts
+var COLORS = {
+  ...flattenColors(TAILWIND_COLORS),
+  // Add basic colors
+  white: "#FFFFFF",
+  black: "#000000",
+  transparent: "transparent"
+};
 function applyOpacity(hex, opacity) {
   if (hex === "transparent") {
     return "transparent";
@@ -1611,6 +1619,16 @@ var TEXT_TRANSFORM_MAP = {
   capitalize: { textTransform: "capitalize" },
   "normal-case": { textTransform: "none" }
 };
+var LINE_HEIGHT_SCALE = {
+  3: 12,
+  4: 16,
+  5: 20,
+  6: 24,
+  7: 28,
+  8: 32,
+  9: 36,
+  10: 40
+};
 var LINE_HEIGHT_MAP = {
   "leading-none": { lineHeight: 16 },
   "leading-tight": { lineHeight: 20 },
@@ -1675,12 +1693,50 @@ function parseTypography(cls) {
     if (arbitraryValue !== null) {
       return { lineHeight: arbitraryValue };
     }
+    const lineHeight = LINE_HEIGHT_SCALE[heightKey];
+    if (lineHeight !== void 0) {
+      return { lineHeight };
+    }
   }
   return FONT_FAMILY_MAP[cls] ?? FONT_WEIGHT_MAP[cls] ?? FONT_STYLE_MAP[cls] ?? TEXT_ALIGN_MAP[cls] ?? TEXT_DECORATION_MAP[cls] ?? TEXT_TRANSFORM_MAP[cls] ?? LINE_HEIGHT_MAP[cls] ?? TRACKING_MAP[cls] ?? null;
 }
 
+// src/parser/placeholder.ts
+function parsePlaceholderClass(cls, customColors) {
+  if (!cls.startsWith("text-")) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        `[react-native-tailwind] Only text color utilities are supported in placeholder: modifier. Class "${cls}" will be ignored. React Native only supports placeholderTextColor prop.`
+      );
+    }
+    return null;
+  }
+  const styleObject = parseColor(cls, customColors);
+  if (!styleObject?.color) {
+    return null;
+  }
+  return styleObject.color;
+}
+function parsePlaceholderClasses(classes, customColors) {
+  const classList = classes.trim().split(/\s+/).filter(Boolean);
+  let finalColor = null;
+  for (const cls of classList) {
+    const color = parsePlaceholderClass(cls, customColors);
+    if (color) {
+      finalColor = color;
+    }
+  }
+  return finalColor;
+}
+
 // src/parser/modifiers.ts
-var SUPPORTED_MODIFIERS = ["active", "hover", "focus", "disabled"];
+var SUPPORTED_MODIFIERS = [
+  "active",
+  "hover",
+  "focus",
+  "disabled",
+  "placeholder"
+];
 function parseModifier(cls) {
   const colonIndex = cls.indexOf(":");
   if (colonIndex === -1) {
@@ -1801,18 +1857,6 @@ function loadTailwindConfig(configPath) {
     return null;
   }
 }
-function flattenColors2(colors, prefix = "") {
-  const result = {};
-  for (const [key, value] of Object.entries(colors)) {
-    const newKey = prefix ? `${prefix}-${key}` : key;
-    if (typeof value === "string") {
-      result[newKey] = value;
-    } else if (typeof value === "object" && value !== null) {
-      Object.assign(result, flattenColors2(value, newKey));
-    }
-  }
-  return result;
-}
 function extractCustomColors(filename) {
   const projectDir = path.dirname(filename);
   const configPath = findTailwindConfig(projectDir);
@@ -1829,37 +1873,46 @@ function extractCustomColors(filename) {
     );
   }
   const colors = config.theme.extend?.colors ?? config.theme.colors ?? {};
-  return flattenColors2(colors);
+  return flattenColors(colors);
 }
 
-// src/babel/index.ts
-var STYLES_IDENTIFIER = "_twStyles";
-var SUPPORTED_CLASS_ATTRIBUTES = [
+// src/babel/utils/attributeMatchers.ts
+var DEFAULT_CLASS_ATTRIBUTES = [
   "className",
-  "containerClassName",
   "contentContainerClassName",
   "columnWrapperClassName",
   "ListHeaderComponentClassName",
   "ListFooterComponentClassName"
 ];
-function getTargetStyleProp(attributeName) {
-  if (attributeName === "containerClassName") {
-    return "containerStyle";
-  }
-  if (attributeName === "contentContainerClassName") {
-    return "contentContainerStyle";
-  }
-  if (attributeName === "columnWrapperClassName") {
-    return "columnWrapperStyle";
+function buildAttributeMatchers(attributes) {
+  const exactMatches = /* @__PURE__ */ new Set();
+  const patterns = [];
+  for (const attr of attributes) {
+    if (attr.includes("*")) {
+      const regexPattern = "^" + attr.replace(/\*/g, ".*") + "$";
+      patterns.push(new RegExp(regexPattern));
+    } else {
+      exactMatches.add(attr);
+    }
   }
-  if (attributeName === "ListHeaderComponentClassName") {
-    return "ListHeaderComponentStyle";
+  return { exactMatches, patterns };
+}
+function isAttributeSupported(attributeName, exactMatches, patterns) {
+  if (exactMatches.has(attributeName)) {
+    return true;
   }
-  if (attributeName === "ListFooterComponentClassName") {
-    return "ListFooterComponentStyle";
+  for (const pattern of patterns) {
+    if (pattern.test(attributeName)) {
+      return true;
+    }
   }
-  return "style";
+  return false;
+}
+function getTargetStyleProp(attributeName) {
+  return attributeName.endsWith("ClassName") ? attributeName.replace("ClassName", "Style") : "style";
 }
+
+// src/babel/utils/componentSupport.ts
 function getComponentModifierSupport(jsxElement, t) {
   if (!t.isJSXOpeningElement(jsxElement)) {
     return null;
@@ -1882,24 +1935,40 @@ function getComponentModifierSupport(jsxElement, t) {
     case "Pressable":
       return { component: "Pressable", supportedModifiers: ["active", "hover", "focus", "disabled"] };
     case "TextInput":
-      return { component: "TextInput", supportedModifiers: ["focus", "disabled"] };
+      return { component: "TextInput", supportedModifiers: ["focus", "disabled", "placeholder"] };
     default:
       return null;
   }
 }
-function processDynamicExpression(expression, state, t) {
+function getStatePropertyForModifier(modifier) {
+  switch (modifier) {
+    case "active":
+      return "pressed";
+    case "hover":
+      return "hovered";
+    case "focus":
+      return "focused";
+    case "disabled":
+      return "disabled";
+    default:
+      return "pressed";
+  }
+}
+
+// src/babel/utils/dynamicProcessing.ts
+function processDynamicExpression(expression, state, parseClassName2, generateStyleKey2, t) {
   if (t.isTemplateLiteral(expression)) {
-    return processTemplateLiteral(expression, state, t);
+    return processTemplateLiteral(expression, state, parseClassName2, generateStyleKey2, t);
   }
   if (t.isConditionalExpression(expression)) {
-    return processConditionalExpression(expression, state, t);
+    return processConditionalExpression(expression, state, parseClassName2, generateStyleKey2, t);
   }
   if (t.isLogicalExpression(expression)) {
-    return processLogicalExpression(expression, state, t);
+    return processLogicalExpression(expression, state, parseClassName2, generateStyleKey2, t);
   }
   return null;
 }
-function processTemplateLiteral(node, state, t) {
+function processTemplateLiteral(node, state, parseClassName2, generateStyleKey2, t) {
   const parts = [];
   const staticParts = [];
   for (let i = 0; i < node.quasis.length; i++) {
@@ -1912,12 +1981,18 @@ function processTemplateLiteral(node, state, t) {
         const styleKey = generateStyleKey2(cls);
         state.styleRegistry.set(styleKey, styleObject);
         staticParts.push(cls);
-        parts.push(t.memberExpression(t.identifier(STYLES_IDENTIFIER), t.identifier(styleKey)));
+        parts.push(t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(styleKey)));
       }
     }
     if (i < node.expressions.length) {
       const expr = node.expressions[i];
-      const result = processDynamicExpression(expr, state, t);
+      const result = processDynamicExpression(
+        expr,
+        state,
+        parseClassName2,
+        generateStyleKey2,
+        t
+      );
       if (result) {
         parts.push(result.expression);
       } else {
@@ -1934,9 +2009,9 @@ function processTemplateLiteral(node, state, t) {
     staticParts: staticParts.length > 0 ? staticParts : void 0
   };
 }
-function processConditionalExpression(node, state, t) {
-  const consequent = processStringOrExpression(node.consequent, state, t);
-  const alternate = processStringOrExpression(node.alternate, state, t);
+function processConditionalExpression(node, state, parseClassName2, generateStyleKey2, t) {
+  const consequent = processStringOrExpression(node.consequent, state, parseClassName2, generateStyleKey2, t);
+  const alternate = processStringOrExpression(node.alternate, state, parseClassName2, generateStyleKey2, t);
   if (!consequent && !alternate) {
     return null;
   }
@@ -1947,18 +2022,18 @@ function processConditionalExpression(node, state, t) {
   );
   return { expression };
 }
-function processLogicalExpression(node, state, t) {
+function processLogicalExpression(node, state, parseClassName2, generateStyleKey2, t) {
   if (node.operator !== "&&") {
     return null;
   }
-  const right = processStringOrExpression(node.right, state, t);
+  const right = processStringOrExpression(node.right, state, parseClassName2, generateStyleKey2, t);
   if (!right) {
     return null;
   }
   const expression = t.logicalExpression("&&", node.left, right);
   return { expression };
 }
-function processStringOrExpression(node, state, t) {
+function processStringOrExpression(node, state, parseClassName2, generateStyleKey2, t) {
   if (t.isStringLiteral(node)) {
     const className = node.value.trim();
     if (!className) {
@@ -1967,31 +2042,33 @@ function processStringOrExpression(node, state, t) {
     const styleObject = parseClassName2(className, state.customColors);
     const styleKey = generateStyleKey2(className);
     state.styleRegistry.set(styleKey, styleObject);
-    return t.memberExpression(t.identifier(STYLES_IDENTIFIER), t.identifier(styleKey));
+    return t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(styleKey));
   }
   if (t.isConditionalExpression(node)) {
-    const result = processConditionalExpression(node, state, t);
+    const result = processConditionalExpression(node, state, parseClassName2, generateStyleKey2, t);
     return result?.expression ?? null;
   }
   if (t.isLogicalExpression(node)) {
-    const result = processLogicalExpression(node, state, t);
+    const result = processLogicalExpression(node, state, parseClassName2, generateStyleKey2, t);
     return result?.expression ?? null;
   }
   if (t.isTemplateLiteral(node)) {
-    const result = processTemplateLiteral(node, state, t);
+    const result = processTemplateLiteral(node, state, parseClassName2, generateStyleKey2, t);
     return result?.expression ?? null;
   }
   return null;
 }
-function processStaticClassNameWithModifiers(className, state, t) {
-  const { baseClasses, modifierClasses } = splitModifierClasses(className);
+
+// src/babel/utils/modifierProcessing.ts
+function processStaticClassNameWithModifiers(className, state, parseClassName2, generateStyleKey2, splitModifierClasses2, t) {
+  const { baseClasses, modifierClasses } = splitModifierClasses2(className);
   let baseStyleExpression = null;
   if (baseClasses.length > 0) {
     const baseClassName = baseClasses.join(" ");
     const baseStyleObject = parseClassName2(baseClassName, state.customColors);
     const baseStyleKey = generateStyleKey2(baseClassName);
     state.styleRegistry.set(baseStyleKey, baseStyleObject);
-    baseStyleExpression = t.memberExpression(t.identifier(STYLES_IDENTIFIER), t.identifier(baseStyleKey));
+    baseStyleExpression = t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(baseStyleKey));
   }
   const modifiersByType = /* @__PURE__ */ new Map();
   for (const mod of modifierClasses) {
@@ -2016,7 +2093,7 @@ function processStaticClassNameWithModifiers(className, state, t) {
     const conditionalExpression = t.logicalExpression(
       "&&",
       t.identifier(stateProperty),
-      t.memberExpression(t.identifier(STYLES_IDENTIFIER), t.identifier(modifierStyleKey))
+      t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(modifierStyleKey))
     );
     styleArrayElements.push(conditionalExpression);
   }
@@ -2025,20 +2102,6 @@ function processStaticClassNameWithModifiers(className, state, t) {
   }
   return t.arrayExpression(styleArrayElements);
 }
-function getStatePropertyForModifier(modifier) {
-  switch (modifier) {
-    case "active":
-      return "pressed";
-    case "hover":
-      return "hovered";
-    case "focus":
-      return "focused";
-    case "disabled":
-      return "disabled";
-    default:
-      return "pressed";
-  }
-}
 function createStyleFunction(styleExpression, modifierTypes, t) {
   const paramProperties = [];
   const usedStateProps = /* @__PURE__ */ new Set();
@@ -2054,9 +2117,236 @@ function createStyleFunction(styleExpression, modifierTypes, t) {
   const param = t.objectPattern(paramProperties);
   return t.arrowFunctionExpression([param], styleExpression);
 }
-function reactNativeTailwindBabelPlugin({
-  types: t
-}) {
+
+// src/babel/utils/styleInjection.ts
+function addStyleSheetImport(path2, t) {
+  const importDeclaration = t.importDeclaration(
+    [t.importSpecifier(t.identifier("StyleSheet"), t.identifier("StyleSheet"))],
+    t.stringLiteral("react-native")
+  );
+  path2.unshiftContainer("body", importDeclaration);
+}
+function injectStylesAtTop(path2, styleRegistry, stylesIdentifier, t) {
+  const styleProperties = [];
+  for (const [key, styleObject] of styleRegistry) {
+    const properties = Object.entries(styleObject).map(([styleProp, styleValue]) => {
+      let valueNode;
+      if (typeof styleValue === "number") {
+        valueNode = t.numericLiteral(styleValue);
+      } else if (typeof styleValue === "string") {
+        valueNode = t.stringLiteral(styleValue);
+      } else {
+        valueNode = t.valueToNode(styleValue);
+      }
+      return t.objectProperty(t.identifier(styleProp), valueNode);
+    });
+    styleProperties.push(t.objectProperty(t.identifier(key), t.objectExpression(properties)));
+  }
+  const styleSheet = t.variableDeclaration("const", [
+    t.variableDeclarator(
+      t.identifier(stylesIdentifier),
+      t.callExpression(t.memberExpression(t.identifier("StyleSheet"), t.identifier("create")), [
+        t.objectExpression(styleProperties)
+      ])
+    )
+  ]);
+  const body = path2.node.body;
+  let insertIndex = 0;
+  for (let i = 0; i < body.length; i++) {
+    if (t.isImportDeclaration(body[i])) {
+      insertIndex = i + 1;
+    } else {
+      break;
+    }
+  }
+  body.splice(insertIndex, 0, styleSheet);
+}
+
+// src/babel/utils/styleTransforms.ts
+function getStyleExpression(styleAttribute, t) {
+  const value = styleAttribute.value;
+  if (!t.isJSXExpressionContainer(value)) return null;
+  const expression = value.expression;
+  if (t.isJSXEmptyExpression(expression)) return null;
+  return expression;
+}
+function findStyleAttribute(path2, targetStyleProp, t) {
+  const parent = path2.parent;
+  return parent.attributes.find(
+    (attr) => t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === targetStyleProp
+  );
+}
+function replaceWithStyleAttribute(classNamePath, styleKey, targetStyleProp, stylesIdentifier, t) {
+  const styleAttribute = t.jsxAttribute(
+    t.jsxIdentifier(targetStyleProp),
+    t.jsxExpressionContainer(t.memberExpression(t.identifier(stylesIdentifier), t.identifier(styleKey)))
+  );
+  classNamePath.replaceWith(styleAttribute);
+}
+function mergeStyleAttribute(classNamePath, styleAttribute, styleKey, stylesIdentifier, t) {
+  const existingStyle = getStyleExpression(styleAttribute, t);
+  if (!existingStyle) return;
+  if (t.isArrowFunctionExpression(existingStyle) || t.isFunctionExpression(existingStyle)) {
+    const paramIdentifier = t.identifier("_state");
+    const functionCall = t.callExpression(existingStyle, [paramIdentifier]);
+    const mergedArray = t.arrayExpression([
+      t.memberExpression(t.identifier(stylesIdentifier), t.identifier(styleKey)),
+      functionCall
+    ]);
+    const wrapperFunction = t.arrowFunctionExpression([paramIdentifier], mergedArray);
+    styleAttribute.value = t.jsxExpressionContainer(wrapperFunction);
+  } else {
+    const styleArray = t.arrayExpression([
+      t.memberExpression(t.identifier(stylesIdentifier), t.identifier(styleKey)),
+      existingStyle
+    ]);
+    styleAttribute.value = t.jsxExpressionContainer(styleArray);
+  }
+  classNamePath.remove();
+}
+function replaceDynamicWithStyleAttribute(classNamePath, result, targetStyleProp, t) {
+  const styleAttribute = t.jsxAttribute(
+    t.jsxIdentifier(targetStyleProp),
+    t.jsxExpressionContainer(result.expression)
+  );
+  classNamePath.replaceWith(styleAttribute);
+}
+function mergeDynamicStyleAttribute(classNamePath, styleAttribute, result, t) {
+  const existingStyle = getStyleExpression(styleAttribute, t);
+  if (!existingStyle) return;
+  if (t.isArrowFunctionExpression(existingStyle) || t.isFunctionExpression(existingStyle)) {
+    const paramIdentifier = t.identifier("_state");
+    const functionCall = t.callExpression(existingStyle, [paramIdentifier]);
+    const mergedArray = t.arrayExpression([result.expression, functionCall]);
+    const wrapperFunction = t.arrowFunctionExpression([paramIdentifier], mergedArray);
+    styleAttribute.value = t.jsxExpressionContainer(wrapperFunction);
+  } else {
+    let styleArray;
+    if (t.isArrayExpression(existingStyle)) {
+      styleArray = t.arrayExpression([result.expression, ...existingStyle.elements]);
+    } else {
+      styleArray = t.arrayExpression([result.expression, existingStyle]);
+    }
+    styleAttribute.value = t.jsxExpressionContainer(styleArray);
+  }
+  classNamePath.remove();
+}
+function replaceWithStyleFunctionAttribute(classNamePath, styleFunctionExpression, targetStyleProp, t) {
+  const styleAttribute = t.jsxAttribute(
+    t.jsxIdentifier(targetStyleProp),
+    t.jsxExpressionContainer(styleFunctionExpression)
+  );
+  classNamePath.replaceWith(styleAttribute);
+}
+function mergeStyleFunctionAttribute(classNamePath, styleAttribute, styleFunctionExpression, t) {
+  const existingStyle = getStyleExpression(styleAttribute, t);
+  if (!existingStyle) return;
+  if (t.isArrowFunctionExpression(existingStyle) || t.isFunctionExpression(existingStyle)) {
+    const paramIdentifier = t.identifier("_state");
+    const newFunctionCall = t.callExpression(styleFunctionExpression, [paramIdentifier]);
+    const existingFunctionCall = t.callExpression(existingStyle, [paramIdentifier]);
+    const mergedArray = t.arrayExpression([newFunctionCall, existingFunctionCall]);
+    const wrapperFunction = t.arrowFunctionExpression([paramIdentifier], mergedArray);
+    styleAttribute.value = t.jsxExpressionContainer(wrapperFunction);
+  } else {
+    const paramIdentifier = t.identifier("_state");
+    const functionCall = t.callExpression(styleFunctionExpression, [paramIdentifier]);
+    const mergedArray = t.arrayExpression([functionCall, existingStyle]);
+    const wrapperFunction = t.arrowFunctionExpression([paramIdentifier], mergedArray);
+    styleAttribute.value = t.jsxExpressionContainer(wrapperFunction);
+  }
+  classNamePath.remove();
+}
+function addOrMergePlaceholderTextColorProp(jsxOpeningElement, color, t) {
+  const existingProp = jsxOpeningElement.attributes.find(
+    (attr) => t.isJSXAttribute(attr) && attr.name.name === "placeholderTextColor"
+  );
+  if (existingProp) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        `[react-native-tailwind] placeholderTextColor prop will be overridden by className placeholder: modifier. Remove the explicit prop or the placeholder: modifier to avoid confusion.`
+      );
+    }
+    existingProp.value = t.stringLiteral(color);
+  } else {
+    const newProp = t.jsxAttribute(t.jsxIdentifier("placeholderTextColor"), t.stringLiteral(color));
+    jsxOpeningElement.attributes.push(newProp);
+  }
+}
+
+// src/babel/utils/twProcessing.ts
+function processTwCall(className, path2, state, parseClassName2, generateStyleKey2, splitModifierClasses2, t) {
+  const { baseClasses, modifierClasses } = splitModifierClasses2(className);
+  const objectProperties = [];
+  if (baseClasses.length > 0) {
+    const baseClassName = baseClasses.join(" ");
+    const baseStyleObject = parseClassName2(baseClassName, state.customColors);
+    const baseStyleKey = generateStyleKey2(baseClassName);
+    state.styleRegistry.set(baseStyleKey, baseStyleObject);
+    objectProperties.push(
+      t.objectProperty(
+        t.identifier("style"),
+        t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(baseStyleKey))
+      )
+    );
+  } else {
+    objectProperties.push(t.objectProperty(t.identifier("style"), t.objectExpression([])));
+  }
+  const modifiersByType = /* @__PURE__ */ new Map();
+  for (const mod of modifierClasses) {
+    if (!modifiersByType.has(mod.modifier)) {
+      modifiersByType.set(mod.modifier, []);
+    }
+    const modGroup = modifiersByType.get(mod.modifier);
+    if (modGroup) {
+      modGroup.push(mod);
+    }
+  }
+  for (const [modifierType, modifiers] of modifiersByType) {
+    const modifierClassNames = modifiers.map((m) => m.baseClass).join(" ");
+    const modifierStyleObject = parseClassName2(modifierClassNames, state.customColors);
+    const modifierStyleKey = generateStyleKey2(`${modifierType}_${modifierClassNames}`);
+    state.styleRegistry.set(modifierStyleKey, modifierStyleObject);
+    const propertyName = `${modifierType}Style`;
+    objectProperties.push(
+      t.objectProperty(
+        t.identifier(propertyName),
+        t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(modifierStyleKey))
+      )
+    );
+  }
+  const twStyleObject = t.objectExpression(objectProperties);
+  path2.replaceWith(twStyleObject);
+}
+function removeTwImports(path2, t) {
+  path2.traverse({
+    ImportDeclaration(importPath) {
+      const node = importPath.node;
+      if (node.source.value !== "@mgcrea/react-native-tailwind") {
+        return;
+      }
+      const remainingSpecifiers = node.specifiers.filter((spec) => {
+        if (t.isImportSpecifier(spec) && t.isIdentifier(spec.imported)) {
+          const importedName = spec.imported.name;
+          return importedName !== "tw" && importedName !== "twStyle";
+        }
+        return true;
+      });
+      if (remainingSpecifiers.length === 0) {
+        importPath.remove();
+      } else if (remainingSpecifiers.length < node.specifiers.length) {
+        node.specifiers = remainingSpecifiers;
+      }
+    }
+  });
+}
+
+// src/babel/plugin.ts
+var DEFAULT_STYLES_IDENTIFIER = "_twStyles";
+function reactNativeTailwindBabelPlugin({ types: t }, options) {
+  const attributes = options?.attributes ?? [...DEFAULT_CLASS_ATTRIBUTES];
+  const { exactMatches, patterns } = buildAttributeMatchers(attributes);
+  const stylesIdentifier = options?.stylesIdentifier ?? DEFAULT_STYLES_IDENTIFIER;
   return {
     name: "react-native-tailwind",
     visitor: {
@@ -2065,19 +2355,27 @@ function reactNativeTailwindBabelPlugin({
           state.styleRegistry = /* @__PURE__ */ new Map();
           state.hasClassNames = false;
           state.hasStyleSheetImport = false;
+          state.supportedAttributes = exactMatches;
+          state.attributePatterns = patterns;
+          state.stylesIdentifier = stylesIdentifier;
+          state.twImportNames = /* @__PURE__ */ new Set();
+          state.hasTwImport = false;
           state.customColors = extractCustomColors(state.file.opts.filename ?? "");
         },
         exit(path2, state) {
+          if (state.hasTwImport) {
+            removeTwImports(path2, t);
+          }
           if (!state.hasClassNames || state.styleRegistry.size === 0) {
             return;
           }
           if (!state.hasStyleSheetImport) {
             addStyleSheetImport(path2, t);
           }
-          injectStyles(path2, state.styleRegistry, t);
+          injectStylesAtTop(path2, state.styleRegistry, state.stylesIdentifier, t);
         }
       },
-      // Check if StyleSheet is already imported
+      // Check if StyleSheet is already imported and track tw/twStyle imports
       ImportDeclaration(path2, state) {
         const node = path2.node;
         if (node.source.value === "react-native") {
@@ -2095,11 +2393,94 @@ function reactNativeTailwindBabelPlugin({
             state.hasStyleSheetImport = true;
           }
         }
+        if (node.source.value === "@mgcrea/react-native-tailwind") {
+          const specifiers = node.specifiers;
+          specifiers.forEach((spec) => {
+            if (t.isImportSpecifier(spec) && t.isIdentifier(spec.imported)) {
+              const importedName = spec.imported.name;
+              if (importedName === "tw" || importedName === "twStyle") {
+                const localName = spec.local.name;
+                state.twImportNames.add(localName);
+                state.hasTwImport = true;
+              }
+            }
+          });
+        }
+      },
+      // Handle tw`...` tagged template expressions
+      TaggedTemplateExpression(path2, state) {
+        const node = path2.node;
+        if (!t.isIdentifier(node.tag)) {
+          return;
+        }
+        const tagName = node.tag.name;
+        if (!state.twImportNames.has(tagName)) {
+          return;
+        }
+        const quasi = node.quasi;
+        if (!t.isTemplateLiteral(quasi)) {
+          return;
+        }
+        if (quasi.expressions.length > 0) {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(
+              `[react-native-tailwind] Dynamic tw\`...\` with interpolations is not supported at ${state.file.opts.filename ?? "unknown"}. Use style prop for dynamic values.`
+            );
+          }
+          return;
+        }
+        const className = quasi.quasis[0]?.value.cooked?.trim() ?? "";
+        if (!className) {
+          path2.replaceWith(
+            t.objectExpression([t.objectProperty(t.identifier("style"), t.objectExpression([]))])
+          );
+          return;
+        }
+        state.hasClassNames = true;
+        processTwCall(className, path2, state, parseClassName, generateStyleKey, splitModifierClasses, t);
+      },
+      // Handle twStyle('...') call expressions
+      CallExpression(path2, state) {
+        const node = path2.node;
+        if (!t.isIdentifier(node.callee)) {
+          return;
+        }
+        const calleeName = node.callee.name;
+        if (!state.twImportNames.has(calleeName)) {
+          return;
+        }
+        if (node.arguments.length !== 1) {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(
+              `[react-native-tailwind] twStyle() expects exactly one argument at ${state.file.opts.filename ?? "unknown"}`
+            );
+          }
+          return;
+        }
+        const arg = node.arguments[0];
+        if (!t.isStringLiteral(arg)) {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn(
+              `[react-native-tailwind] twStyle() only supports static string literals at ${state.file.opts.filename ?? "unknown"}. Use style prop for dynamic values.`
+            );
+          }
+          return;
+        }
+        const className = arg.value.trim();
+        if (!className) {
+          path2.replaceWith(t.identifier("undefined"));
+          return;
+        }
+        state.hasClassNames = true;
+        processTwCall(className, path2, state, parseClassName, generateStyleKey, splitModifierClasses, t);
       },
       JSXAttribute(path2, state) {
         const node = path2.node;
+        if (!t.isJSXIdentifier(node.name)) {
+          return;
+        }
         const attributeName = node.name.name;
-        if (!SUPPORTED_CLASS_ATTRIBUTES.includes(attributeName)) {
+        if (!isAttributeSupported(attributeName, state.supportedAttributes, state.attributePatterns)) {
           return;
         }
         const value = node.value;
@@ -2112,11 +2493,30 @@ function reactNativeTailwindBabelPlugin({
           }
           state.hasClassNames = true;
           const { baseClasses, modifierClasses } = splitModifierClasses(className);
-          if (modifierClasses.length > 0) {
+          const placeholderModifiers = modifierClasses.filter((m) => m.modifier === "placeholder");
+          const stateModifiers = modifierClasses.filter((m) => m.modifier !== "placeholder");
+          if (placeholderModifiers.length > 0) {
+            const jsxOpeningElement = path2.parent;
+            const componentSupport = getComponentModifierSupport(jsxOpeningElement, t);
+            if (componentSupport?.supportedModifiers.includes("placeholder")) {
+              const placeholderClasses = placeholderModifiers.map((m) => m.baseClass).join(" ");
+              const placeholderColor = parsePlaceholderClasses(placeholderClasses, state.customColors);
+              if (placeholderColor) {
+                addOrMergePlaceholderTextColorProp(jsxOpeningElement, placeholderColor, t);
+              }
+            } else {
+              if (process.env.NODE_ENV !== "production") {
+                console.warn(
+                  `[react-native-tailwind] placeholder: modifier can only be used on TextInput component at ${state.file.opts.filename ?? "unknown"}`
+                );
+              }
+            }
+          }
+          if (stateModifiers.length > 0) {
             const jsxOpeningElement = path2.parent;
             const componentSupport = getComponentModifierSupport(jsxOpeningElement, t);
             if (componentSupport) {
-              const usedModifiers = Array.from(new Set(modifierClasses.map((m) => m.modifier)));
+              const usedModifiers = Array.from(new Set(stateModifiers.map((m) => m.modifier)));
               const unsupportedModifiers = usedModifiers.filter(
                 (mod) => !componentSupport.supportedModifiers.includes(mod)
               );
@@ -2126,7 +2526,7 @@ function reactNativeTailwindBabelPlugin({
                     `[react-native-tailwind] Modifiers (${unsupportedModifiers.map((m) => `${m}:`).join(", ")}) are not supported on ${componentSupport.component} component at ${state.file.opts.filename ?? "unknown"}. Supported modifiers: ${componentSupport.supportedModifiers.join(", ")}`
                   );
                 }
-                const supportedModifierClasses = modifierClasses.filter(
+                const supportedModifierClasses = stateModifiers.filter(
                   (m) => componentSupport.supportedModifiers.includes(m.modifier)
                 );
                 if (supportedModifierClasses.length === 0) {
@@ -2135,14 +2535,14 @@ function reactNativeTailwindBabelPlugin({
                   const styleExpression = processStaticClassNameWithModifiers(
                     filteredClassName.trim(),
                     state,
+                    parseClassName,
+                    generateStyleKey,
+                    splitModifierClasses,
                     t
                   );
                   const modifierTypes = Array.from(new Set(supportedModifierClasses.map((m) => m.modifier)));
                   const styleFunctionExpression = createStyleFunction(styleExpression, modifierTypes, t);
-                  const parent2 = path2.parent;
-                  const styleAttribute2 = parent2.attributes.find(
-                    (attr) => t.isJSXAttribute(attr) && attr.name.name === targetStyleProp
-                  );
+                  const styleAttribute2 = findStyleAttribute(path2, targetStyleProp, t);
                   if (styleAttribute2) {
                     mergeStyleFunctionAttribute(path2, styleAttribute2, styleFunctionExpression, t);
                   } else {
@@ -2151,13 +2551,17 @@ function reactNativeTailwindBabelPlugin({
                   return;
                 }
               } else {
-                const styleExpression = processStaticClassNameWithModifiers(className, state, t);
+                const styleExpression = processStaticClassNameWithModifiers(
+                  className,
+                  state,
+                  parseClassName,
+                  generateStyleKey,
+                  splitModifierClasses,
+                  t
+                );
                 const modifierTypes = usedModifiers;
                 const styleFunctionExpression = createStyleFunction(styleExpression, modifierTypes, t);
-                const parent2 = path2.parent;
-                const styleAttribute2 = parent2.attributes.find(
-                  (attr) => t.isJSXAttribute(attr) && attr.name.name === targetStyleProp
-                );
+                const styleAttribute2 = findStyleAttribute(path2, targetStyleProp, t);
                 if (styleAttribute2) {
                   mergeStyleFunctionAttribute(path2, styleAttribute2, styleFunctionExpression, t);
                 } else {
@@ -2167,24 +2571,26 @@ function reactNativeTailwindBabelPlugin({
               }
             } else {
               if (process.env.NODE_ENV !== "production") {
-                const usedModifiers = Array.from(new Set(modifierClasses.map((m) => m.modifier)));
+                const usedModifiers = Array.from(new Set(stateModifiers.map((m) => m.modifier)));
                 console.warn(
                   `[react-native-tailwind] Modifiers (${usedModifiers.map((m) => `${m}:`).join(", ")}) can only be used on compatible components (Pressable, TextInput). Found on unsupported element at ${state.file.opts.filename ?? "unknown"}`
                 );
               }
             }
           }
-          const styleObject = parseClassName2(className, state.customColors);
-          const styleKey = generateStyleKey2(className);
+          const classNameForStyle = baseClasses.join(" ");
+          if (!classNameForStyle) {
+            path2.remove();
+            return;
+          }
+          const styleObject = parseClassName(classNameForStyle, state.customColors);
+          const styleKey = generateStyleKey(classNameForStyle);
           state.styleRegistry.set(styleKey, styleObject);
-          const parent = path2.parent;
-          const styleAttribute = parent.attributes.find(
-            (attr) => t.isJSXAttribute(attr) && attr.name.name === targetStyleProp
-          );
+          const styleAttribute = findStyleAttribute(path2, targetStyleProp, t);
           if (styleAttribute) {
-            mergeStyleAttribute(path2, styleAttribute, styleKey, t);
+            mergeStyleAttribute(path2, styleAttribute, styleKey, state.stylesIdentifier, t);
           } else {
-            replaceWithStyleAttribute(path2, styleKey, targetStyleProp, t);
+            replaceWithStyleAttribute(path2, styleKey, targetStyleProp, state.stylesIdentifier, t);
           }
           return;
         }
@@ -2194,13 +2600,10 @@ function reactNativeTailwindBabelPlugin({
             return;
           }
           try {
-            const result = processDynamicExpression(expression, state, t);
+            const result = processDynamicExpression(expression, state, parseClassName, generateStyleKey, t);
             if (result) {
               state.hasClassNames = true;
-              const parent = path2.parent;
-              const styleAttribute = parent.attributes.find(
-                (attr) => t.isJSXAttribute(attr) && attr.name.name === targetStyleProp
-              );
+              const styleAttribute = findStyleAttribute(path2, targetStyleProp, t);
               if (styleAttribute) {
                 mergeDynamicStyleAttribute(path2, styleAttribute, result, t);
               } else {
@@ -2226,101 +2629,3 @@ function reactNativeTailwindBabelPlugin({
     }
   };
 }
-function addStyleSheetImport(path2, t) {
-  const importDeclaration = t.importDeclaration(
-    [t.importSpecifier(t.identifier("StyleSheet"), t.identifier("StyleSheet"))],
-    t.stringLiteral("react-native")
-  );
-  path2.unshiftContainer("body", importDeclaration);
-}
-function replaceWithStyleAttribute(classNamePath, styleKey, targetStyleProp, t) {
-  const styleAttribute = t.jsxAttribute(
-    t.jsxIdentifier(targetStyleProp),
-    t.jsxExpressionContainer(t.memberExpression(t.identifier(STYLES_IDENTIFIER), t.identifier(styleKey)))
-  );
-  classNamePath.replaceWith(styleAttribute);
-}
-function mergeStyleAttribute(classNamePath, styleAttribute, styleKey, t) {
-  const existingStyle = styleAttribute.value.expression;
-  const styleArray = t.arrayExpression([
-    t.memberExpression(t.identifier(STYLES_IDENTIFIER), t.identifier(styleKey)),
-    existingStyle
-  ]);
-  styleAttribute.value = t.jsxExpressionContainer(styleArray);
-  classNamePath.remove();
-}
-function replaceDynamicWithStyleAttribute(classNamePath, result, targetStyleProp, t) {
-  const styleAttribute = t.jsxAttribute(
-    t.jsxIdentifier(targetStyleProp),
-    t.jsxExpressionContainer(result.expression)
-  );
-  classNamePath.replaceWith(styleAttribute);
-}
-function mergeDynamicStyleAttribute(classNamePath, styleAttribute, result, t) {
-  const existingStyle = styleAttribute.value.expression;
-  let styleArray;
-  if (t.isArrayExpression(existingStyle)) {
-    styleArray = t.arrayExpression([result.expression, ...existingStyle.elements]);
-  } else {
-    styleArray = t.arrayExpression([result.expression, existingStyle]);
-  }
-  styleAttribute.value = t.jsxExpressionContainer(styleArray);
-  classNamePath.remove();
-}
-function replaceWithStyleFunctionAttribute(classNamePath, styleFunctionExpression, targetStyleProp, t) {
-  const styleAttribute = t.jsxAttribute(
-    t.jsxIdentifier(targetStyleProp),
-    t.jsxExpressionContainer(styleFunctionExpression)
-  );
-  classNamePath.replaceWith(styleAttribute);
-}
-function mergeStyleFunctionAttribute(classNamePath, styleAttribute, styleFunctionExpression, t) {
-  const existingStyle = styleAttribute.value.expression;
-  if (t.isArrowFunctionExpression(existingStyle) || t.isFunctionExpression(existingStyle)) {
-    const paramIdentifier = t.identifier("_state");
-    const newFunctionCall = t.callExpression(styleFunctionExpression, [paramIdentifier]);
-    const existingFunctionCall = t.callExpression(existingStyle, [paramIdentifier]);
-    const mergedArray = t.arrayExpression([newFunctionCall, existingFunctionCall]);
-    const wrapperFunction = t.arrowFunctionExpression([paramIdentifier], mergedArray);
-    styleAttribute.value = t.jsxExpressionContainer(wrapperFunction);
-  } else {
-    const paramIdentifier = t.identifier("_state");
-    const functionCall = t.callExpression(styleFunctionExpression, [paramIdentifier]);
-    const mergedArray = t.arrayExpression([functionCall, existingStyle]);
-    const wrapperFunction = t.arrowFunctionExpression([paramIdentifier], mergedArray);
-    styleAttribute.value = t.jsxExpressionContainer(wrapperFunction);
-  }
-  classNamePath.remove();
-}
-function injectStyles(path2, styleRegistry, t) {
-  const styleProperties = [];
-  for (const [key, styleObject] of styleRegistry) {
-    const properties = Object.entries(styleObject).map(([styleProp, styleValue]) => {
-      let valueNode;
-      if (typeof styleValue === "number") {
-        valueNode = t.numericLiteral(styleValue);
-      } else if (typeof styleValue === "string") {
-        valueNode = t.stringLiteral(styleValue);
-      } else {
-        valueNode = t.valueToNode(styleValue);
-      }
-      return t.objectProperty(t.identifier(styleProp), valueNode);
-    });
-    styleProperties.push(t.objectProperty(t.identifier(key), t.objectExpression(properties)));
-  }
-  const styleSheet = t.variableDeclaration("const", [
-    t.variableDeclarator(
-      t.identifier(STYLES_IDENTIFIER),
-      t.callExpression(t.memberExpression(t.identifier("StyleSheet"), t.identifier("create")), [
-        t.objectExpression(styleProperties)
-      ])
-    )
-  ]);
-  path2.pushContainer("body", styleSheet);
-}
-function parseClassName2(className, customColors) {
-  return parseClassName(className, customColors);
-}
-function generateStyleKey2(className) {
-  return generateStyleKey(className);
-}