@mgcrea/react-native-tailwind 0.13.0 → 0.15.0

package/src/babel/utils/directionalModifierProcessing.ts

@@ -0,0 +1,99 @@
+/**
+ * Utility functions for processing directional modifiers (rtl:, ltr:)
+ */
+
+import type * as BabelTypes from "@babel/types";
+import type { CustomTheme, DirectionalModifierType, ParsedModifier } from "../../parser/index.js";
+import type { StyleObject } from "../../types/core.js";
+import { hasRuntimeDimensions } from "./windowDimensionsProcessing.js";
+
+/**
+ * Plugin state interface (subset needed for directional modifier processing)
+ */
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export interface DirectionalModifierProcessingState {
+  styleRegistry: Map<string, StyleObject>;
+  customTheme: CustomTheme;
+  stylesIdentifier: string;
+  needsI18nManagerImport: boolean;
+  i18nManagerVariableName: string;
+}
+
+/**
+ * Process directional modifiers and generate conditional style expressions
+ *
+ * @param directionalModifiers - Array of parsed directional modifiers
+ * @param state - Plugin state
+ * @param parseClassName - Function to parse class names into style objects
+ * @param generateStyleKey - Function to generate unique style keys
+ * @param t - Babel types
+ * @returns Array of AST nodes for conditional expressions
+ *
+ * @example
+ * Input: [{ modifier: "rtl", baseClass: "mr-4" }, { modifier: "ltr", baseClass: "ml-4" }]
+ * Output: [
+ *   _twIsRTL && styles._rtl_mr_4,
+ *   !_twIsRTL && styles._ltr_ml_4
+ * ]
+ */
+export function processDirectionalModifiers(
+  directionalModifiers: ParsedModifier[],
+  state: DirectionalModifierProcessingState,
+  parseClassName: (className: string, customTheme?: CustomTheme) => StyleObject,
+  generateStyleKey: (className: string) => string,
+  t: typeof BabelTypes,
+): BabelTypes.Expression[] {
+  // Mark that we need I18nManager import
+  state.needsI18nManagerImport = true;
+
+  // Group modifiers by direction (rtl, ltr)
+  const modifiersByDirection = new Map<DirectionalModifierType, ParsedModifier[]>();
+
+  for (const mod of directionalModifiers) {
+    const direction = mod.modifier as DirectionalModifierType;
+    if (!modifiersByDirection.has(direction)) {
+      modifiersByDirection.set(direction, []);
+    }
+    const directionGroup = modifiersByDirection.get(direction);
+    if (directionGroup) {
+      directionGroup.push(mod);
+    }
+  }
+
+  // Build conditional expressions for each direction
+  const conditionalExpressions: BabelTypes.Expression[] = [];
+
+  for (const [direction, modifiers] of modifiersByDirection) {
+    // Parse all classes for this direction together
+    const classNames = modifiers.map((m) => m.baseClass).join(" ");
+    const styleObject = parseClassName(classNames, state.customTheme);
+
+    // Check for runtime dimensions (w-screen, h-screen)
+    if (hasRuntimeDimensions(styleObject)) {
+      throw new Error(
+        `w-screen and h-screen cannot be combined with directional modifiers (rtl:, ltr:). ` +
+          `Found in: "${direction}:${classNames}". ` +
+          `Use w-screen/h-screen without modifiers instead.`,
+      );
+    }
+
+    const styleKey = generateStyleKey(`${direction}_${classNames}`);
+
+    // Register style in the registry
+    state.styleRegistry.set(styleKey, styleObject);
+
+    // Create conditional:
+    // - For rtl: _twIsRTL && styles._rtl_...
+    // - For ltr: !_twIsRTL && styles._ltr_...
+    const rtlVariable = t.identifier(state.i18nManagerVariableName);
+    const directionCheck = direction === "rtl" ? rtlVariable : t.unaryExpression("!", rtlVariable);
+
+    const styleReference = t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(styleKey));
+
+    const conditionalExpression = t.logicalExpression("&&", directionCheck, styleReference);
+
+    conditionalExpressions.push(conditionalExpression);
+  }
+
+  return conditionalExpressions;
+}

package/src/babel/utils/styleInjection.ts

@@ -220,6 +220,128 @@ export function injectColorSchemeHook(
   return true;
 }
 
+/**
+ * Add I18nManager import to the file or merge with existing react-native import
+ */
+export function addI18nManagerImport(path: NodePath<BabelTypes.Program>, t: typeof BabelTypes): void {
+  // Check if there's already a value import from react-native
+  const body = path.node.body;
+  let existingValueImport: BabelTypes.ImportDeclaration | null = null;
+
+  for (const statement of body) {
+    if (t.isImportDeclaration(statement) && statement.source.value === "react-native") {
+      // Skip type-only imports (they get erased at runtime)
+      if (statement.importKind === "type") {
+        continue;
+      }
+      // Skip namespace imports (import * as RN) - can't add named specifiers to them
+      const hasNamespaceImport = statement.specifiers.some((spec) => t.isImportNamespaceSpecifier(spec));
+      if (hasNamespaceImport) {
+        continue;
+      }
+      existingValueImport = statement;
+      break; // Found a value import, we can stop
+    }
+  }
+
+  if (existingValueImport) {
+    // Check if I18nManager is already imported
+    const hasI18nManager = existingValueImport.specifiers.some(
+      (spec) =>
+        t.isImportSpecifier(spec) &&
+        spec.imported.type === "Identifier" &&
+        spec.imported.name === "I18nManager",
+    );
+
+    if (!hasI18nManager) {
+      // Add I18nManager to existing value import
+      existingValueImport.specifiers.push(
+        t.importSpecifier(t.identifier("I18nManager"), t.identifier("I18nManager")),
+      );
+    }
+  } else {
+    // No value import exists - create a new one
+    // (Don't merge with type-only or namespace imports)
+    const importDeclaration = t.importDeclaration(
+      [t.importSpecifier(t.identifier("I18nManager"), t.identifier("I18nManager"))],
+      t.stringLiteral("react-native"),
+    );
+    path.unshiftContainer("body", importDeclaration);
+  }
+}
+
+/**
+ * Inject I18nManager.isRTL variable at the top of the file (after imports and directives)
+ *
+ * Unlike hooks (useColorScheme, useWindowDimensions), I18nManager.isRTL is not a hook
+ * and can be accessed at module level. This is injected once per file.
+ *
+ * @param path - Program path
+ * @param variableName - Name for the RTL variable (e.g., '_twIsRTL')
+ * @param localIdentifier - Local identifier if I18nManager is already imported with an alias
+ * @param t - Babel types
+ */
+export function injectI18nManagerVariable(
+  path: NodePath<BabelTypes.Program>,
+  variableName: string,
+  localIdentifier: string | undefined,
+  t: typeof BabelTypes,
+): void {
+  const body = path.node.body;
+
+  // Check if variable is already declared
+  for (const statement of body) {
+    if (
+      t.isVariableDeclaration(statement) &&
+      statement.declarations.length > 0 &&
+      t.isVariableDeclarator(statement.declarations[0])
+    ) {
+      const declarator = statement.declarations[0];
+      if (t.isIdentifier(declarator.id) && declarator.id.name === variableName) {
+        return; // Already injected
+      }
+    }
+  }
+
+  // Use the local identifier if I18nManager was already imported with an alias,
+  // otherwise use 'I18nManager'
+  // e.g., import { I18nManager as RTL } → use RTL.isRTL
+  const identifierToUse = localIdentifier ?? "I18nManager";
+
+  // Create: const _twIsRTL = I18nManager.isRTL; (or aliased name if already imported)
+  const i18nVariable = t.variableDeclaration("const", [
+    t.variableDeclarator(
+      t.identifier(variableName),
+      t.memberExpression(t.identifier(identifierToUse), t.identifier("isRTL")),
+    ),
+  ]);
+
+  // Find the index to insert after all imports and directives ('use client', 'use strict', etc.)
+  let insertIndex = 0;
+
+  for (let i = 0; i < body.length; i++) {
+    const statement = body[i];
+
+    // Skip directives ('use client', 'use strict', etc.)
+    if (t.isExpressionStatement(statement) && t.isStringLiteral(statement.expression)) {
+      insertIndex = i + 1;
+      continue;
+    }
+
+    // Skip imports
+    if (t.isImportDeclaration(statement)) {
+      insertIndex = i + 1;
+      continue;
+    }
+
+    // Stop at the first non-directive, non-import statement
+    break;
+  }
+
+  // Insert after imports and directives
+  body.splice(insertIndex, 0, i18nVariable);
+}
+
 /**
  * Add useWindowDimensions import to the file or merge with existing react-native import
  */
@@ -377,20 +499,29 @@ export function injectStylesAtTop(
     ),
   ]);
 
-  // Find the index to insert after all imports
+  // Find the index to insert after all imports and directives ('use client', 'use strict', etc.)
   const body = path.node.body;
   let insertIndex = 0;
 
-  // Find the last import statement
   for (let i = 0; i < body.length; i++) {
-    if (t.isImportDeclaration(body[i])) {
+    const statement = body[i];
+
+    // Skip directives ('use client', 'use strict', etc.)
+    if (t.isExpressionStatement(statement) && t.isStringLiteral(statement.expression)) {
       insertIndex = i + 1;
-    } else {
-      // Stop at the first non-import statement
-      break;
+      continue;
     }
+
+    // Skip imports
+    if (t.isImportDeclaration(statement)) {
+      insertIndex = i + 1;
+      continue;
+    }
+
+    // Stop at the first non-directive, non-import statement
+    break;
   }
 
-  // Insert StyleSheet.create after imports
+  // Insert StyleSheet.create after imports and directives
   body.splice(insertIndex, 0, styleSheet);
 }

package/src/babel/utils/twProcessing.ts

@@ -8,12 +8,14 @@ import type { CustomTheme, ModifierType, ParsedModifier } from "../../parser/ind
 import {
   expandSchemeModifier,
   isColorSchemeModifier,
+  isDirectionalModifier,
   isPlatformModifier,
   isSchemeModifier,
 } from "../../parser/index.js";
 import type { SchemeModifierConfig } from "../../types/config.js";
 import type { StyleObject } from "../../types/core.js";
 import { processColorSchemeModifiers } from "./colorSchemeModifierProcessing.js";
+import { processDirectionalModifiers } from "./directionalModifierProcessing.js";
 import { processPlatformModifiers } from "./platformModifierProcessing.js";
 import { hasRuntimeDimensions } from "./windowDimensionsProcessing.js";
 
@@ -33,6 +35,9 @@ export interface TwProcessingState {
   colorSchemeLocalIdentifier?: string;
   // Platform support (for ios:/android:/web: modifiers)
   needsPlatformImport: boolean;
+  // Directional support (for rtl:/ltr: modifiers)
+  needsI18nManagerImport: boolean;
+  i18nManagerVariableName: string;
 }
 
 /**
@@ -102,11 +107,15 @@ export function processTwCall(
     objectProperties.push(t.objectProperty(t.identifier("style"), t.objectExpression([])));
   }
 
-  // Separate color-scheme and platform modifiers from other modifiers
+  // Separate color-scheme, platform, and directional modifiers from other modifiers
   const colorSchemeModifiers = modifierClasses.filter((m) => isColorSchemeModifier(m.modifier));
   const platformModifiers = modifierClasses.filter((m) => isPlatformModifier(m.modifier));
+  const directionalModifiers = modifierClasses.filter((m) => isDirectionalModifier(m.modifier));
   const otherModifiers = modifierClasses.filter(
-    (m) => !isColorSchemeModifier(m.modifier) && !isPlatformModifier(m.modifier),
+    (m) =>
+      !isColorSchemeModifier(m.modifier) &&
+      !isPlatformModifier(m.modifier) &&
+      !isDirectionalModifier(m.modifier),
   );
 
   // Check if we need color scheme support
@@ -293,7 +302,87 @@ export function processTwCall(
     }
   }
 
-  // Group other modifiers by type (non-color-scheme and non-platform modifiers)
+  // Process directional modifiers if present
+  const hasDirectionalModifiers = directionalModifiers.length > 0;
+
+  if (hasDirectionalModifiers) {
+    // Mark that we need I18nManager import
+    state.needsI18nManagerImport = true;
+
+    // Generate directional conditional expressions
+    const directionalConditionals = processDirectionalModifiers(
+      directionalModifiers,
+      state,
+      parseClassName,
+      generateStyleKey,
+      t,
+    );
+
+    // If we already have a style array (from color scheme or platform modifiers), add to it
+    // Otherwise, convert style property to an array
+    const styleProperty = objectProperties.find(
+      (prop) => t.isIdentifier(prop.key) && prop.key.name === "style",
+    );
+
+    if (styleProperty && t.isArrayExpression(styleProperty.value)) {
+      // Already have style array, add directional conditionals to it
+      styleProperty.value.elements.push(...directionalConditionals);
+    } else {
+      // No existing array, create style array with base + directional conditionals
+      const styleArrayElements: BabelTypes.Expression[] = [];
+
+      // Add base style if present
+      if (baseClasses.length > 0) {
+        const baseClassName = baseClasses.join(" ");
+        const baseStyleObject = parseClassName(baseClassName, state.customTheme);
+        const baseStyleKey = generateStyleKey(baseClassName);
+        state.styleRegistry.set(baseStyleKey, baseStyleObject);
+        styleArrayElements.push(
+          t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(baseStyleKey)),
+        );
+      }
+
+      // Add directional conditionals
+      styleArrayElements.push(...directionalConditionals);
+
+      // Replace style property with array
+      objectProperties[0] = t.objectProperty(t.identifier("style"), t.arrayExpression(styleArrayElements));
+    }
+
+    // Also add rtlStyle/ltrStyle properties for manual processing
+    const rtlModifiers = directionalModifiers.filter((m) => m.modifier === "rtl");
+    const ltrModifiers = directionalModifiers.filter((m) => m.modifier === "ltr");
+
+    if (rtlModifiers.length > 0) {
+      const rtlClassNames = rtlModifiers.map((m) => m.baseClass).join(" ");
+      const rtlStyleObject = parseClassName(rtlClassNames, state.customTheme);
+      const rtlStyleKey = generateStyleKey(`rtl_${rtlClassNames}`);
+      state.styleRegistry.set(rtlStyleKey, rtlStyleObject);
+
+      objectProperties.push(
+        t.objectProperty(
+          t.identifier("rtlStyle"),
+          t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(rtlStyleKey)),
+        ),
+      );
+    }
+
+    if (ltrModifiers.length > 0) {
+      const ltrClassNames = ltrModifiers.map((m) => m.baseClass).join(" ");
+      const ltrStyleObject = parseClassName(ltrClassNames, state.customTheme);
+      const ltrStyleKey = generateStyleKey(`ltr_${ltrClassNames}`);
+      state.styleRegistry.set(ltrStyleKey, ltrStyleObject);
+
+      objectProperties.push(
+        t.objectProperty(
+          t.identifier("ltrStyle"),
+          t.memberExpression(t.identifier(state.stylesIdentifier), t.identifier(ltrStyleKey)),
+        ),
+      );
+    }
+  }
+
+  // Group other modifiers by type (non-color-scheme, non-platform, and non-directional modifiers)
   const modifiersByType = new Map<ModifierType, ParsedModifier[]>();
   for (const mod of otherModifiers) {
     if (!modifiersByType.has(mod.modifier)) {

package/src/parser/borders.test.ts

@@ -385,3 +385,107 @@ describe("parseBorder - color pattern detection", () => {
     expect(parseBorder("border-l-[8px]")).toEqual({ borderLeftWidth: 8 });
   });
 });
+
+describe("parseBorder - logical border width (RTL-aware)", () => {
+  it("should parse border start width", () => {
+    expect(parseBorder("border-s")).toEqual({ borderStartWidth: 1 });
+    expect(parseBorder("border-s-0")).toEqual({ borderStartWidth: 0 });
+    expect(parseBorder("border-s-2")).toEqual({ borderStartWidth: 2 });
+    expect(parseBorder("border-s-4")).toEqual({ borderStartWidth: 4 });
+    expect(parseBorder("border-s-8")).toEqual({ borderStartWidth: 8 });
+  });
+
+  it("should parse border end width", () => {
+    expect(parseBorder("border-e")).toEqual({ borderEndWidth: 1 });
+    expect(parseBorder("border-e-0")).toEqual({ borderEndWidth: 0 });
+    expect(parseBorder("border-e-2")).toEqual({ borderEndWidth: 2 });
+    expect(parseBorder("border-e-4")).toEqual({ borderEndWidth: 4 });
+    expect(parseBorder("border-e-8")).toEqual({ borderEndWidth: 8 });
+  });
+
+  it("should parse border start/end with arbitrary values", () => {
+    expect(parseBorder("border-s-[3px]")).toEqual({ borderStartWidth: 3 });
+    expect(parseBorder("border-s-[5]")).toEqual({ borderStartWidth: 5 });
+    expect(parseBorder("border-e-[3px]")).toEqual({ borderEndWidth: 3 });
+    expect(parseBorder("border-e-[5]")).toEqual({ borderEndWidth: 5 });
+  });
+});
+
+describe("parseBorder - logical border radius sides (RTL-aware)", () => {
+  it("should parse rounded start (both top and bottom start corners)", () => {
+    expect(parseBorder("rounded-s")).toEqual({
+      borderTopStartRadius: 4,
+      borderBottomStartRadius: 4,
+    });
+    expect(parseBorder("rounded-s-lg")).toEqual({
+      borderTopStartRadius: 8,
+      borderBottomStartRadius: 8,
+    });
+    expect(parseBorder("rounded-s-[12px]")).toEqual({
+      borderTopStartRadius: 12,
+      borderBottomStartRadius: 12,
+    });
+  });
+
+  it("should parse rounded end (both top and bottom end corners)", () => {
+    expect(parseBorder("rounded-e")).toEqual({
+      borderTopEndRadius: 4,
+      borderBottomEndRadius: 4,
+    });
+    expect(parseBorder("rounded-e-lg")).toEqual({
+      borderTopEndRadius: 8,
+      borderBottomEndRadius: 8,
+    });
+    expect(parseBorder("rounded-e-[12px]")).toEqual({
+      borderTopEndRadius: 12,
+      borderBottomEndRadius: 12,
+    });
+  });
+});
+
+describe("parseBorder - logical border radius corners (RTL-aware)", () => {
+  it("should parse rounded start-start (top-start corner)", () => {
+    expect(parseBorder("rounded-ss")).toEqual({ borderTopStartRadius: 4 });
+    expect(parseBorder("rounded-ss-lg")).toEqual({ borderTopStartRadius: 8 });
+    expect(parseBorder("rounded-ss-[12px]")).toEqual({
+      borderTopStartRadius: 12,
+    });
+  });
+
+  it("should parse rounded start-end (top-end corner)", () => {
+    expect(parseBorder("rounded-se")).toEqual({ borderTopEndRadius: 4 });
+    expect(parseBorder("rounded-se-lg")).toEqual({ borderTopEndRadius: 8 });
+    expect(parseBorder("rounded-se-[12px]")).toEqual({
+      borderTopEndRadius: 12,
+    });
+  });
+
+  it("should parse rounded end-start (bottom-start corner)", () => {
+    expect(parseBorder("rounded-es")).toEqual({ borderBottomStartRadius: 4 });
+    expect(parseBorder("rounded-es-lg")).toEqual({ borderBottomStartRadius: 8 });
+    expect(parseBorder("rounded-es-[12px]")).toEqual({
+      borderBottomStartRadius: 12,
+    });
+  });
+
+  it("should parse rounded end-end (bottom-end corner)", () => {
+    expect(parseBorder("rounded-ee")).toEqual({ borderBottomEndRadius: 4 });
+    expect(parseBorder("rounded-ee-lg")).toEqual({ borderBottomEndRadius: 8 });
+    expect(parseBorder("rounded-ee-[12px]")).toEqual({
+      borderBottomEndRadius: 12,
+    });
+  });
+
+  it("should parse all logical corners with different sizes", () => {
+    // Using full scale to verify all sizes work
+    expect(parseBorder("rounded-ss-none")).toEqual({ borderTopStartRadius: 0 });
+    expect(parseBorder("rounded-se-sm")).toEqual({ borderTopEndRadius: 2 });
+    expect(parseBorder("rounded-es-md")).toEqual({ borderBottomStartRadius: 6 });
+    expect(parseBorder("rounded-ee-xl")).toEqual({ borderBottomEndRadius: 12 });
+    expect(parseBorder("rounded-ss-2xl")).toEqual({ borderTopStartRadius: 16 });
+    expect(parseBorder("rounded-se-3xl")).toEqual({ borderTopEndRadius: 24 });
+    expect(parseBorder("rounded-es-full")).toEqual({
+      borderBottomStartRadius: 9999,
+    });
+  });
+});

package/src/parser/borders.ts

@@ -35,10 +35,12 @@ const BORDER_WIDTH_PROP_MAP: Record<string, string> = {
   r: "borderRightWidth",
   b: "borderBottomWidth",
   l: "borderLeftWidth",
+  s: "borderStartWidth",
+  e: "borderEndWidth",
 };
 
 /**
- * Property mapping for border radius corners
+ * Property mapping for border radius corners (physical)
  */
 const BORDER_RADIUS_CORNER_MAP: Record<string, string> = {
   tl: "borderTopLeftRadius",
@@ -47,6 +49,18 @@ const BORDER_RADIUS_CORNER_MAP: Record<string, string> = {
   br: "borderBottomRightRadius",
 };
 
+/**
+ * Property mapping for border radius corners (logical/RTL-aware)
+ * ss = start-start (top-start), se = start-end (top-end)
+ * es = end-start (bottom-start), ee = end-end (bottom-end)
+ */
+const BORDER_RADIUS_LOGICAL_CORNER_MAP: Record<string, string> = {
+  ss: "borderTopStartRadius",
+  se: "borderTopEndRadius",
+  es: "borderBottomStartRadius",
+  ee: "borderBottomEndRadius",
+};
+
 /**
  * Property mapping for border radius sides (returns array of properties)
  */
@@ -55,6 +69,8 @@ const BORDER_RADIUS_SIDE_MAP: Record<string, string[]> = {
   r: ["borderTopRightRadius", "borderBottomRightRadius"],
   b: ["borderBottomLeftRadius", "borderBottomRightRadius"],
   l: ["borderTopLeftRadius", "borderBottomLeftRadius"],
+  s: ["borderTopStartRadius", "borderBottomStartRadius"],
+  e: ["borderTopEndRadius", "borderBottomEndRadius"],
 };
 
 /**
@@ -141,16 +157,17 @@ export function parseBorder(cls: string, customColors?: Record<string, string>):
  * @param customColors - Optional custom colors (passed to parseColor for pattern detection)
  */
 function parseBorderWidth(cls: string, customColors?: Record<string, string>): StyleObject | null {
-  // Directional borders: border-t, border-t-2, border-t-[8px]
+  // Directional borders: border-t, border-t-2, border-t-[8px], border-s, border-e (RTL-aware)
   // Note: border-x and border-y are handled by parseColor for colors only
-  const dirMatch = cls.match(/^border-([trbl])(?:-(.+))?$/);
+  const dirMatch = cls.match(/^border-([trblse])(?:-(.+))?$/);
   if (dirMatch) {
     const dir = dirMatch[1];
     const valueStr = dirMatch[2] || ""; // empty string for border-t
 
     // If it's a color pattern, let parseColor handle it
     // Try to parse as color - if it succeeds, return null (let parseColor handle it)
-    if (valueStr) {
+    // Note: We skip color check for s/e since React Native doesn't support borderStartColor/borderEndColor
+    if (valueStr && dir !== "s" && dir !== "e") {
       const colorResult = parseColor(cls, customColors);
       if (colorResult !== null) {
         return null; // It's a color, let parseColor handle it
@@ -220,7 +237,7 @@ function parseBorderRadius(cls: string): StyleObject | null {
     return null;
   }
 
-  // Specific corners: rounded-tl, rounded-tl-lg, rounded-tl-[8px]
+  // Specific physical corners: rounded-tl, rounded-tl-lg, rounded-tl-[8px]
   const cornerMatch = rest.match(/^(tl|tr|bl|br)(?:-(.+))?$/);
   if (cornerMatch) {
     const corner = cornerMatch[1];
@@ -244,8 +261,34 @@ function parseBorderRadius(cls: string): StyleObject | null {
     return null;
   }
 
-  // Sides: rounded-t, rounded-t-lg, rounded-t-[8px]
-  const sideMatch = rest.match(/^([trbl])(?:-(.+))?$/);
+  // Logical corners (RTL-aware): rounded-ss, rounded-se, rounded-es, rounded-ee
+  // ss = start-start (top-start), se = start-end (top-end)
+  // es = end-start (bottom-start), ee = end-end (bottom-end)
+  const logicalCornerMatch = rest.match(/^(ss|se|es|ee)(?:-(.+))?$/);
+  if (logicalCornerMatch) {
+    const corner = logicalCornerMatch[1];
+    const valueStr = logicalCornerMatch[2] || ""; // empty string for rounded-ss
+
+    // Try arbitrary value first
+    if (valueStr.startsWith("[")) {
+      const arbitraryValue = parseArbitraryBorderRadius(valueStr);
+      if (arbitraryValue !== null) {
+        return { [BORDER_RADIUS_LOGICAL_CORNER_MAP[corner]]: arbitraryValue };
+      }
+      return null;
+    }
+
+    // Try preset scale
+    const scaleValue = BORDER_RADIUS_SCALE[valueStr];
+    if (scaleValue !== undefined) {
+      return { [BORDER_RADIUS_LOGICAL_CORNER_MAP[corner]]: scaleValue };
+    }
+
+    return null;
+  }
+
+  // Sides: rounded-t, rounded-t-lg, rounded-t-[8px], rounded-s, rounded-e (RTL-aware)
+  const sideMatch = rest.match(/^([trblse])(?:-(.+))?$/);
   if (sideMatch) {
     const side = sideMatch[1];
     const valueStr = sideMatch[2] || ""; // empty string for rounded-t

package/src/parser/index.ts

@@ -21,6 +21,7 @@ export type CustomTheme = {
   colors?: Record<string, string>;
   fontFamily?: Record<string, string>;
   fontSize?: Record<string, number>;
+  spacing?: Record<string, number>;
 };
 
 /**
@@ -50,17 +51,17 @@ export function parseClassName(className: string, customTheme?: CustomTheme): St
 export function parseClass(cls: string, customTheme?: CustomTheme): StyleObject {
   // Try each parser in order
   // Note: parseBorder must come before parseColor to avoid border-[3px] being parsed as a color
-  // parseBorder, parseColor and parseTypography get custom theme
+  // Parsers receive relevant custom theme properties
   const parsers: Array<(cls: string) => StyleObject | null> = [
-    parseSpacing,
+    (cls: string) => parseSpacing(cls, customTheme?.spacing),
     (cls: string) => parseBorder(cls, customTheme?.colors),
     (cls: string) => parseColor(cls, customTheme?.colors),
-    parseLayout,
+    (cls: string) => parseLayout(cls, customTheme?.spacing),
     (cls: string) => parseTypography(cls, customTheme?.fontFamily, customTheme?.fontSize),
-    parseSizing,
+    (cls: string) => parseSizing(cls, customTheme?.spacing),
     parseShadow,
     parseAspectRatio,
-    parseTransform,
+    (cls: string) => parseTransform(cls, customTheme?.spacing),
   ];
 
   for (const parser of parsers) {
@@ -97,6 +98,7 @@ export {
   hasModifier,
   isColorClass,
   isColorSchemeModifier,
+  isDirectionalModifier,
   isPlatformModifier,
   isSchemeModifier,
   isStateModifier,
@@ -105,6 +107,7 @@ export {
 } from "./modifiers";
 export type {
   ColorSchemeModifierType,
+  DirectionalModifierType,
   ModifierType,
   ParsedModifier,
   PlatformModifierType,