@mgcrea/react-native-tailwind 0.8.1 → 0.9.1

package/README.md

@@ -45,6 +45,7 @@ Compile-time Tailwind CSS for React Native with zero runtime overhead. Transform
 - 🔀 **Dynamic className** — Conditional styles with hybrid compile-time optimization
 - 🏃 **Runtime option** — Optional `tw` template tag for fully dynamic styling (~25KB)
 - 🎯 **State modifiers** — `active:`, `hover:`, `focus:`, and `disabled:` modifiers for interactive components
+- 📱 **Platform modifiers** — `ios:`, `android:`, and `web:` modifiers for platform-specific styling
 - 📜 **Special style props** — Support for `contentContainerClassName`, `columnWrapperClassName`, and more
 - 🎛️ **Custom attributes** — Configure which props to transform with exact matching or glob patterns
 
@@ -709,6 +710,157 @@ The enhanced `TextInput` also provides a convenient `disabled` prop that overrid
 - ✅ **Type-safe** — Full TypeScript autocomplete for all modifiers
 - ✅ **Works with custom colors** — `focus:border-primary`, `active:bg-secondary`, `disabled:bg-gray-200`, etc.
 
+### Platform Modifiers
+
+Apply platform-specific styles using `ios:`, `android:`, and `web:` modifiers. These work on **all components** (not just enhanced ones) and compile to `Platform.select()` calls with zero runtime parsing overhead.
+
+**Basic Example:**
+
+```tsx
+import { View, Text } from "react-native";
+
+export function PlatformCard() {
+  return (
+    <View className="p-4 ios:p-6 android:p-8 bg-white rounded-lg">
+      <Text className="text-base ios:text-blue-600 android:text-green-600">
+        Platform-specific styles
+      </Text>
+    </View>
+  );
+}
+```
+
+**Transforms to:**
+
+```tsx
+import { Platform, StyleSheet } from "react-native";
+
+<View
+  style={[
+    _twStyles._bg_white_p_4_rounded_lg,
+    Platform.select({
+      ios: _twStyles._ios_p_6,
+      android: _twStyles._android_p_8,
+    }),
+  ]}
+>
+  <Text
+    style={[
+      _twStyles._text_base,
+      Platform.select({
+        ios: _twStyles._ios_text_blue_600,
+        android: _twStyles._android_text_green_600,
+      }),
+    ]}
+  >
+    Platform-specific styles
+  </Text>
+</View>;
+
+// Generated styles:
+const _twStyles = StyleSheet.create({
+  _bg_white_p_4_rounded_lg: {
+    backgroundColor: "#FFFFFF",
+    padding: 16,
+    borderRadius: 8,
+  },
+  _ios_p_6: { padding: 24 },
+  _android_p_8: { padding: 32 },
+  _text_base: { fontSize: 16 },
+  _ios_text_blue_600: { color: "#2563EB" },
+  _android_text_green_600: { color: "#059669" },
+});
+```
+
+**Common Use Cases:**
+
+**Platform-specific colors:**
+
+```tsx
+// Different colors per platform for brand consistency
+<View className="bg-blue-500 ios:bg-blue-600 android:bg-green-600">
+  <Text className="text-white">Platform-specific background</Text>
+</View>
+```
+
+**Platform-specific spacing:**
+
+```tsx
+// More padding on Android due to larger default touch targets
+<View className="p-4 ios:p-6 android:p-8">
+  <Text>Platform-specific padding</Text>
+</View>
+```
+
+**Combined with base styles:**
+
+```tsx
+// Base styles + platform-specific overrides
+<View className="border-2 border-gray-300 ios:border-blue-500 android:border-green-500 rounded-lg p-4">
+  <Text className="text-gray-800 ios:text-blue-800 android:text-green-800">
+    Base styles with platform overrides
+  </Text>
+</View>
+```
+
+**Multiple platform modifiers:**
+
+```tsx
+// Combine multiple platform-specific styles
+<View className="bg-gray-100 ios:bg-blue-50 android:bg-green-50 p-4 ios:p-6 android:p-8 rounded-lg">
+  <Text>Multiple platform styles</Text>
+</View>
+```
+
+**Web platform support:**
+
+```tsx
+// Different styles for React Native Web
+<View className="p-4 ios:p-6 android:p-8 web:p-2">
+  <Text className="text-base web:text-lg">Cross-platform styling</Text>
+</View>
+```
+
+**Mixing with state modifiers:**
+
+```tsx
+import { Pressable } from "@mgcrea/react-native-tailwind";
+
+// Platform modifiers work alongside state modifiers
+<Pressable className="bg-blue-500 active:bg-blue-700 ios:border-2 android:border-0 p-4 rounded-lg">
+  <Text className="text-white">Button with platform + state modifiers</Text>
+</Pressable>;
+```
+
+**Key Features:**
+
+- ✅ **Works on all components** — No need for enhanced components (unlike state modifiers)
+- ✅ **Zero runtime overhead** — All parsing happens at compile-time
+- ✅ **Native Platform API** — Uses React Native's `Platform.select()` under the hood
+- ✅ **Type-safe** — Full TypeScript autocomplete for platform modifiers
+- ✅ **Optimized** — Styles deduplicated via `StyleSheet.create`
+- ✅ **Works with custom colors** — `ios:bg-primary`, `android:bg-secondary`, etc.
+- ✅ **Minimal runtime cost** — Only one `Platform.select()` call per element with platform modifiers
+
+**Supported Platforms:**
+
+| Modifier | Platform       | Description                   |
+| -------- | -------------- | ----------------------------- |
+| `ios:`   | iOS            | Styles specific to iOS        |
+| `android:` | Android      | Styles specific to Android    |
+| `web:`   | React Native Web | Styles for web platform     |
+
+**How it works:**
+
+The Babel plugin:
+1. Detects platform modifiers during compilation
+2. Parses all platform-specific classes at compile-time
+3. Generates `Platform.select()` expressions with references to pre-compiled styles
+4. Auto-imports `Platform` from `react-native` when needed
+5. Merges platform styles with base classes and other modifiers in style arrays
+
+This approach provides the best of both worlds: compile-time optimization for all styles, with minimal runtime platform detection only for the conditional selection logic.
+
 ### ScrollView Content Container
 
 Use `contentContainerClassName` to style the ScrollView's content container:

package/dist/babel/config-loader.ts

@@ -72,6 +72,7 @@ export function loadTailwindConfig(configPath: string): TailwindConfig | null {
     configCache.set(configPath, resolved);
     return resolved;
   } catch (error) {
+    /* v8 ignore next 3 */
     if (process.env.NODE_ENV !== "production") {
       console.warn(`[react-native-tailwind] Failed to load config from ${configPath}:`, error);
     }
@@ -98,6 +99,7 @@ export function extractCustomColors(filename: string): Record<string, string> {
   }
 
   // Warn if using theme.colors instead of theme.extend.colors
+  /* v8 ignore next 5 */
   if (config.theme.colors && !config.theme.extend?.colors && process.env.NODE_ENV !== "production") {
     console.warn(
       "[react-native-tailwind] Using theme.colors will override all default colors. " +

package/dist/babel/index.cjs

@@ -65,7 +65,7 @@ function parseAspectRatio(cls) {
   if (cls in ASPECT_RATIO_PRESETS) {
     const aspectRatio2 = ASPECT_RATIO_PRESETS[cls];
     if (aspectRatio2 === void 0) {
-      return {};
+      return { aspectRatio: void 0 };
     }
     return { aspectRatio: aspectRatio2 };
   }
@@ -1209,16 +1209,19 @@ function parseArbitrarySpacing(value) {
   return null;
 }
 function parseSpacing(cls) {
-  const marginMatch = cls.match(/^m([xytrbls]?)-(.+)$/);
+  const marginMatch = cls.match(/^(-?)m([xytrbls]?)-(.+)$/);
   if (marginMatch) {
-    const [, dir, valueStr] = marginMatch;
+    const [, negativePrefix, dir, valueStr] = marginMatch;
+    const isNegative = negativePrefix === "-";
     const arbitraryValue = parseArbitrarySpacing(valueStr);
     if (arbitraryValue !== null) {
-      return getMarginStyle(dir, arbitraryValue);
+      const finalValue = isNegative ? -arbitraryValue : arbitraryValue;
+      return getMarginStyle(dir, finalValue);
     }
     const scaleValue = SPACING_SCALE[valueStr];
     if (scaleValue !== void 0) {
-      return getMarginStyle(dir, scaleValue);
+      const finalValue = isNegative ? -scaleValue : scaleValue;
+      return getMarginStyle(dir, finalValue);
     }
   }
   const paddingMatch = cls.match(/^p([xytrbls]?)-(.+)$/);
@@ -1730,13 +1733,15 @@ function parsePlaceholderClasses(classes, customColors) {
 }
 
 // src/parser/modifiers.ts
-var SUPPORTED_MODIFIERS = [
+var STATE_MODIFIERS = [
   "active",
   "hover",
   "focus",
   "disabled",
   "placeholder"
 ];
+var PLATFORM_MODIFIERS = ["ios", "android", "web"];
+var SUPPORTED_MODIFIERS = [...STATE_MODIFIERS, ...PLATFORM_MODIFIERS];
 function parseModifier(cls) {
   const colonIndex = cls.indexOf(":");
   if (colonIndex === -1) {
@@ -1758,6 +1763,12 @@ function parseModifier(cls) {
     baseClass
   };
 }
+function isStateModifier(modifier) {
+  return STATE_MODIFIERS.includes(modifier);
+}
+function isPlatformModifier(modifier) {
+  return PLATFORM_MODIFIERS.includes(modifier);
+}
 function splitModifierClasses(className) {
   const classes = className.trim().split(/\s+/).filter(Boolean);
   const baseClasses = [];
@@ -2118,13 +2129,74 @@ function createStyleFunction(styleExpression, modifierTypes, t) {
   return t.arrowFunctionExpression([param], styleExpression);
 }
 
+// src/babel/utils/platformModifierProcessing.ts
+function processPlatformModifiers(platformModifiers, state, parseClassName2, generateStyleKey2, t) {
+  state.needsPlatformImport = true;
+  const modifiersByPlatform = /* @__PURE__ */ new Map();
+  for (const mod of platformModifiers) {
+    const platform = mod.modifier;
+    if (!modifiersByPlatform.has(platform)) {
+      modifiersByPlatform.set(platform, []);
+    }
+    const platformGroup = modifiersByPlatform.get(platform);
+    if (platformGroup) {
+      platformGroup.push(mod);
+    }
+  }
+  const selectProperties = [];
+  for (const [platform, modifiers] of modifiersByPlatform) {
+    const classNames = modifiers.map((m) => m.baseClass).join(" ");
+    const styleObject = parseClassName2(classNames, state.customColors);
+    const styleKey = generateStyleKey2(`${platform}_${classNames}`);
+    state.styleRegistry.set(styleKey, styleObject);
+    const styleReference = t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(styleKey));
+    selectProperties.push(t.objectProperty(t.identifier(platform), styleReference));
+  }
+  return t.callExpression(t.memberExpression(t.identifier("Platform"), t.identifier("select")), [
+    t.objectExpression(selectProperties)
+  ]);
+}
+
 // 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);
+  const body = path2.node.body;
+  let reactNativeImport = null;
+  for (const statement of body) {
+    if (t.isImportDeclaration(statement) && statement.source.value === "react-native") {
+      reactNativeImport = statement;
+      break;
+    }
+  }
+  if (reactNativeImport) {
+    reactNativeImport.specifiers.push(
+      t.importSpecifier(t.identifier("StyleSheet"), t.identifier("StyleSheet"))
+    );
+  } else {
+    const importDeclaration = t.importDeclaration(
+      [t.importSpecifier(t.identifier("StyleSheet"), t.identifier("StyleSheet"))],
+      t.stringLiteral("react-native")
+    );
+    path2.unshiftContainer("body", importDeclaration);
+  }
+}
+function addPlatformImport(path2, t) {
+  const body = path2.node.body;
+  let reactNativeImport = null;
+  for (const statement of body) {
+    if (t.isImportDeclaration(statement) && statement.source.value === "react-native") {
+      reactNativeImport = statement;
+      break;
+    }
+  }
+  if (reactNativeImport) {
+    reactNativeImport.specifiers.push(t.importSpecifier(t.identifier("Platform"), t.identifier("Platform")));
+  } else {
+    const importDeclaration = t.importDeclaration(
+      [t.importSpecifier(t.identifier("Platform"), t.identifier("Platform"))],
+      t.stringLiteral("react-native")
+    );
+    path2.unshiftContainer("body", importDeclaration);
+  }
 }
 function injectStylesAtTop(path2, styleRegistry, stylesIdentifier, t) {
   const styleProperties = [];
@@ -2355,6 +2427,8 @@ function reactNativeTailwindBabelPlugin({ types: t }, options) {
           state.styleRegistry = /* @__PURE__ */ new Map();
           state.hasClassNames = false;
           state.hasStyleSheetImport = false;
+          state.hasPlatformImport = false;
+          state.needsPlatformImport = false;
           state.supportedAttributes = exactMatches;
           state.attributePatterns = patterns;
           state.stylesIdentifier = stylesIdentifier;
@@ -2372,10 +2446,13 @@ function reactNativeTailwindBabelPlugin({ types: t }, options) {
           if (!state.hasStyleSheetImport) {
             addStyleSheetImport(path2, t);
           }
+          if (state.needsPlatformImport && !state.hasPlatformImport) {
+            addPlatformImport(path2, t);
+          }
           injectStylesAtTop(path2, state.styleRegistry, state.stylesIdentifier, t);
         }
       },
-      // Check if StyleSheet is already imported and track tw/twStyle imports
+      // Check if StyleSheet/Platform are already imported and track tw/twStyle imports
       ImportDeclaration(path2, state) {
         const node = path2.node;
         if (node.source.value === "react-native") {
@@ -2386,12 +2463,19 @@ function reactNativeTailwindBabelPlugin({ types: t }, options) {
             }
             return false;
           });
+          const hasPlatform = specifiers.some((spec) => {
+            if (t.isImportSpecifier(spec) && t.isIdentifier(spec.imported)) {
+              return spec.imported.name === "Platform";
+            }
+            return false;
+          });
           if (hasStyleSheet) {
             state.hasStyleSheetImport = true;
-          } else {
-            node.specifiers.push(t.importSpecifier(t.identifier("StyleSheet"), t.identifier("StyleSheet")));
-            state.hasStyleSheetImport = true;
           }
+          if (hasPlatform) {
+            state.hasPlatformImport = true;
+          }
+          state.reactNativeImportPath = path2;
         }
         if (node.source.value === "@mgcrea/react-native-tailwind") {
           const specifiers = node.specifiers;
@@ -2494,7 +2578,10 @@ function reactNativeTailwindBabelPlugin({ types: t }, options) {
           state.hasClassNames = true;
           const { baseClasses, modifierClasses } = splitModifierClasses(className);
           const placeholderModifiers = modifierClasses.filter((m) => m.modifier === "placeholder");
-          const stateModifiers = modifierClasses.filter((m) => m.modifier !== "placeholder");
+          const platformModifiers = modifierClasses.filter((m) => isPlatformModifier(m.modifier));
+          const stateModifiers = modifierClasses.filter(
+            (m) => isStateModifier(m.modifier) && m.modifier !== "placeholder"
+          );
           if (placeholderModifiers.length > 0) {
             const jsxOpeningElement = path2.parent;
             const componentSupport = getComponentModifierSupport(jsxOpeningElement, t);
@@ -2512,7 +2599,108 @@ function reactNativeTailwindBabelPlugin({ types: t }, options) {
               }
             }
           }
-          if (stateModifiers.length > 0) {
+          const hasPlatformModifiers = platformModifiers.length > 0;
+          const hasStateModifiers = stateModifiers.length > 0;
+          const hasBaseClasses = baseClasses.length > 0;
+          if (hasStateModifiers && hasPlatformModifiers) {
+            const jsxOpeningElement = path2.parent;
+            const componentSupport = getComponentModifierSupport(jsxOpeningElement, t);
+            if (componentSupport) {
+              const styleArrayElements = [];
+              if (hasBaseClasses) {
+                const baseClassName = baseClasses.join(" ");
+                const baseStyleObject = parseClassName(baseClassName, state.customColors);
+                const baseStyleKey = generateStyleKey(baseClassName);
+                state.styleRegistry.set(baseStyleKey, baseStyleObject);
+                styleArrayElements.push(
+                  t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(baseStyleKey))
+                );
+              }
+              const platformSelectExpression = processPlatformModifiers(
+                platformModifiers,
+                state,
+                parseClassName,
+                generateStyleKey,
+                t
+              );
+              styleArrayElements.push(platformSelectExpression);
+              const modifiersByType = /* @__PURE__ */ new Map();
+              for (const mod of stateModifiers) {
+                const modType = mod.modifier;
+                if (!modifiersByType.has(modType)) {
+                  modifiersByType.set(modType, []);
+                }
+                modifiersByType.get(modType)?.push(mod);
+              }
+              for (const [modifierType, modifiers] of modifiersByType) {
+                if (!componentSupport.supportedModifiers.includes(modifierType)) {
+                  continue;
+                }
+                const modifierClassNames = modifiers.map((m) => m.baseClass).join(" ");
+                const modifierStyleObject = parseClassName(modifierClassNames, state.customColors);
+                const modifierStyleKey = generateStyleKey(`${modifierType}_${modifierClassNames}`);
+                state.styleRegistry.set(modifierStyleKey, modifierStyleObject);
+                const stateProperty = getStatePropertyForModifier(modifierType);
+                const conditionalExpression = t.logicalExpression(
+                  "&&",
+                  t.identifier(stateProperty),
+                  t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(modifierStyleKey))
+                );
+                styleArrayElements.push(conditionalExpression);
+              }
+              const usedModifiers = Array.from(new Set(stateModifiers.map((m) => m.modifier))).filter(
+                (mod) => componentSupport.supportedModifiers.includes(mod)
+              );
+              const styleArrayExpression = t.arrayExpression(styleArrayElements);
+              const styleFunctionExpression = createStyleFunction(styleArrayExpression, usedModifiers, t);
+              const styleAttribute2 = findStyleAttribute(path2, targetStyleProp, t);
+              if (styleAttribute2) {
+                mergeStyleFunctionAttribute(path2, styleAttribute2, styleFunctionExpression, t);
+              } else {
+                replaceWithStyleFunctionAttribute(path2, styleFunctionExpression, targetStyleProp, t);
+              }
+              return;
+            } else {
+            }
+          }
+          if (hasPlatformModifiers && !hasStateModifiers) {
+            const styleExpressions = [];
+            if (hasBaseClasses) {
+              const baseClassName = baseClasses.join(" ");
+              const baseStyleObject = parseClassName(baseClassName, state.customColors);
+              const baseStyleKey = generateStyleKey(baseClassName);
+              state.styleRegistry.set(baseStyleKey, baseStyleObject);
+              styleExpressions.push(
+                t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(baseStyleKey))
+              );
+            }
+            const platformSelectExpression = processPlatformModifiers(
+              platformModifiers,
+              state,
+              parseClassName,
+              generateStyleKey,
+              t
+            );
+            styleExpressions.push(platformSelectExpression);
+            const styleExpression = styleExpressions.length === 1 ? styleExpressions[0] : t.arrayExpression(styleExpressions);
+            const styleAttribute2 = findStyleAttribute(path2, targetStyleProp, t);
+            if (styleAttribute2) {
+              const existingStyle = styleAttribute2.value;
+              if (t.isJSXExpressionContainer(existingStyle) && !t.isJSXEmptyExpression(existingStyle.expression)) {
+                const existing = existingStyle.expression;
+                const mergedArray = t.isArrayExpression(existing) ? t.arrayExpression([styleExpression, ...existing.elements]) : t.arrayExpression([styleExpression, existing]);
+                styleAttribute2.value = t.jsxExpressionContainer(mergedArray);
+              } else {
+                styleAttribute2.value = t.jsxExpressionContainer(styleExpression);
+              }
+              path2.remove();
+            } else {
+              path2.node.name = t.jsxIdentifier(targetStyleProp);
+              path2.node.value = t.jsxExpressionContainer(styleExpression);
+            }
+            return;
+          }
+          if (hasStateModifiers) {
             const jsxOpeningElement = path2.parent;
             const componentSupport = getComponentModifierSupport(jsxOpeningElement, t);
             if (componentSupport) {

package/dist/babel/plugin.d.ts

@@ -2,7 +2,7 @@
  * Babel plugin for react-native-tailwind
  * Transforms className props to style props at compile time
  */
-import type { PluginObj, PluginPass } from "@babel/core";
+import type { NodePath, PluginObj, PluginPass } from "@babel/core";
 import * as BabelTypes from "@babel/types";
 import type { StyleObject } from "../types/core.js";
 /**
@@ -29,12 +29,15 @@ type PluginState = PluginPass & {
     styleRegistry: Map<string, StyleObject>;
     hasClassNames: boolean;
     hasStyleSheetImport: boolean;
+    hasPlatformImport: boolean;
+    needsPlatformImport: boolean;
     customColors: Record<string, string>;
     supportedAttributes: Set<string>;
     attributePatterns: RegExp[];
     stylesIdentifier: string;
     twImportNames: Set<string>;
     hasTwImport: boolean;
+    reactNativeImportPath?: NodePath<BabelTypes.ImportDeclaration>;
 };
 export default function reactNativeTailwindBabelPlugin({ types: t }: {
     types: typeof BabelTypes;