@mgcrea/react-native-tailwind 0.8.0 → 0.8.1

package/src/babel/utils/componentSupport.test.ts

@@ -0,0 +1,426 @@
+import { parseSync } from "@babel/core";
+import * as t from "@babel/types";
+import { describe, expect, it } from "vitest";
+import { getComponentModifierSupport, getStatePropertyForModifier } from "./componentSupport";
+
+/**
+ * Helper to create a JSXOpeningElement from JSX code
+ */
+function createJSXElement(code: string): t.JSXOpeningElement {
+  const ast = parseSync(code, {
+    sourceType: "module",
+    plugins: [["@babel/plugin-syntax-jsx", {}]],
+    filename: "test.tsx",
+    configFile: false,
+    babelrc: false,
+  });
+
+  if (!ast) {
+    throw new Error(`Failed to parse: ${code}`);
+  }
+
+  // Find the JSXOpeningElement in the AST
+  let element: t.JSXOpeningElement | null = null;
+
+  const traverse = (node: t.Node) => {
+    if (t.isJSXOpeningElement(node)) {
+      element = node;
+      return;
+    }
+    for (const key in node) {
+      // @ts-expect-error - Dynamic key access
+      if (node[key] && typeof node[key] === "object") {
+        // @ts-expect-error - Dynamic key access
+        traverse(node[key] as t.Node);
+      }
+    }
+  };
+
+  traverse(ast);
+
+  if (!element) {
+    throw new Error(`Could not find JSXOpeningElement in: ${code}`);
+  }
+
+  return element;
+}
+
+describe("getComponentModifierSupport", () => {
+  describe("Supported components", () => {
+    it("should recognize Pressable component", () => {
+      const element = createJSXElement("<Pressable />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toEqual({
+        component: "Pressable",
+        supportedModifiers: ["active", "hover", "focus", "disabled"],
+      });
+    });
+
+    it("should recognize TextInput component", () => {
+      const element = createJSXElement("<TextInput />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toEqual({
+        component: "TextInput",
+        supportedModifiers: ["focus", "disabled", "placeholder"],
+      });
+    });
+
+    it("should recognize Pressable with attributes", () => {
+      const element = createJSXElement('<Pressable className="m-4" onPress={handlePress} />');
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toEqual({
+        component: "Pressable",
+        supportedModifiers: ["active", "hover", "focus", "disabled"],
+      });
+    });
+
+    it("should recognize TextInput with attributes", () => {
+      const element = createJSXElement('<TextInput className="border" placeholder="Email" />');
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toEqual({
+        component: "TextInput",
+        supportedModifiers: ["focus", "disabled", "placeholder"],
+      });
+    });
+  });
+
+  describe("Member expressions", () => {
+    it("should recognize ReactNative.Pressable", () => {
+      const element = createJSXElement("<ReactNative.Pressable />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toEqual({
+        component: "Pressable",
+        supportedModifiers: ["active", "hover", "focus", "disabled"],
+      });
+    });
+
+    it("should recognize RN.TextInput", () => {
+      const element = createJSXElement("<RN.TextInput />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toEqual({
+        component: "TextInput",
+        supportedModifiers: ["focus", "disabled", "placeholder"],
+      });
+    });
+
+    it("should recognize nested member expressions", () => {
+      const element = createJSXElement("<Components.Input.TextInput />");
+      const result = getComponentModifierSupport(element, t);
+
+      // Should extract "TextInput" from the rightmost property
+      expect(result).toEqual({
+        component: "TextInput",
+        supportedModifiers: ["focus", "disabled", "placeholder"],
+      });
+    });
+
+    it("should recognize Pressable in namespaced imports", () => {
+      const element = createJSXElement("<UI.Pressable />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toEqual({
+        component: "Pressable",
+        supportedModifiers: ["active", "hover", "focus", "disabled"],
+      });
+    });
+  });
+
+  describe("Unsupported components", () => {
+    it("should return null for View", () => {
+      const element = createJSXElement("<View />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toBeNull();
+    });
+
+    it("should return null for TouchableOpacity", () => {
+      const element = createJSXElement("<TouchableOpacity />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toBeNull();
+    });
+
+    it("should return null for custom components", () => {
+      const element = createJSXElement("<CustomButton />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toBeNull();
+    });
+
+    it("should return null for Text", () => {
+      const element = createJSXElement("<Text />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toBeNull();
+    });
+
+    it("should return null for Image", () => {
+      const element = createJSXElement("<Image />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should be case-sensitive", () => {
+      // lowercase "pressable" should not match
+      const element = createJSXElement("<pressable />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).toBeNull();
+    });
+
+    it("should not match similar names", () => {
+      const element1 = createJSXElement("<PressableButton />");
+      const result1 = getComponentModifierSupport(element1, t);
+      expect(result1).toBeNull();
+
+      const element2 = createJSXElement("<MyPressable />");
+      const result2 = getComponentModifierSupport(element2, t);
+      expect(result2).toBeNull();
+
+      const element3 = createJSXElement("<TextInputField />");
+      const result3 = getComponentModifierSupport(element3, t);
+      expect(result3).toBeNull();
+    });
+
+    it("should handle self-closing tags", () => {
+      const element = createJSXElement("<Pressable />");
+      const result = getComponentModifierSupport(element, t);
+
+      expect(result).not.toBeNull();
+      expect(result?.component).toBe("Pressable");
+    });
+
+    it("should return null for non-JSXOpeningElement nodes", () => {
+      // Test with a random node type
+      const identifier = t.identifier("foo");
+      const result = getComponentModifierSupport(identifier, t);
+
+      expect(result).toBeNull();
+    });
+
+    it("should return null for JSXFragment", () => {
+      // JSXFragment doesn't have a JSXOpeningElement, so create a mock fragment
+      const fragment = {
+        type: "JSXFragment",
+        openingFragment: {},
+        closingFragment: {},
+        children: [],
+      };
+
+      const result = getComponentModifierSupport(fragment as t.Node, t);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("Modifier support differences", () => {
+    it("should show Pressable supports active modifier but TextInput does not", () => {
+      const pressable = createJSXElement("<Pressable />");
+      const textInput = createJSXElement("<TextInput />");
+
+      const pressableResult = getComponentModifierSupport(pressable, t);
+      const textInputResult = getComponentModifierSupport(textInput, t);
+
+      expect(pressableResult?.supportedModifiers).toContain("active");
+      expect(textInputResult?.supportedModifiers).not.toContain("active");
+    });
+
+    it("should show both support focus modifier", () => {
+      const pressable = createJSXElement("<Pressable />");
+      const textInput = createJSXElement("<TextInput />");
+
+      const pressableResult = getComponentModifierSupport(pressable, t);
+      const textInputResult = getComponentModifierSupport(textInput, t);
+
+      expect(pressableResult?.supportedModifiers).toContain("focus");
+      expect(textInputResult?.supportedModifiers).toContain("focus");
+    });
+
+    it("should show TextInput supports placeholder but Pressable does not", () => {
+      const pressable = createJSXElement("<Pressable />");
+      const textInput = createJSXElement("<TextInput />");
+
+      const pressableResult = getComponentModifierSupport(pressable, t);
+      const textInputResult = getComponentModifierSupport(textInput, t);
+
+      expect(pressableResult?.supportedModifiers).not.toContain("placeholder");
+      expect(textInputResult?.supportedModifiers).toContain("placeholder");
+    });
+
+    it("should show both support disabled modifier", () => {
+      const pressable = createJSXElement("<Pressable />");
+      const textInput = createJSXElement("<TextInput />");
+
+      const pressableResult = getComponentModifierSupport(pressable, t);
+      const textInputResult = getComponentModifierSupport(textInput, t);
+
+      expect(pressableResult?.supportedModifiers).toContain("disabled");
+      expect(textInputResult?.supportedModifiers).toContain("disabled");
+    });
+  });
+});
+
+describe("getStatePropertyForModifier", () => {
+  it("should map active to pressed", () => {
+    expect(getStatePropertyForModifier("active")).toBe("pressed");
+  });
+
+  it("should map hover to hovered", () => {
+    expect(getStatePropertyForModifier("hover")).toBe("hovered");
+  });
+
+  it("should map focus to focused", () => {
+    expect(getStatePropertyForModifier("focus")).toBe("focused");
+  });
+
+  it("should map disabled to disabled", () => {
+    expect(getStatePropertyForModifier("disabled")).toBe("disabled");
+  });
+
+  it("should return pressed as fallback for unknown modifiers", () => {
+    // @ts-expect-error - Testing fallback with invalid modifier
+    expect(getStatePropertyForModifier("unknown")).toBe("pressed");
+
+    // @ts-expect-error - Testing fallback with invalid modifier
+    expect(getStatePropertyForModifier("invalid")).toBe("pressed");
+
+    // @ts-expect-error - Testing fallback with invalid modifier
+    expect(getStatePropertyForModifier("")).toBe("pressed");
+  });
+
+  it("should handle all Pressable modifier states", () => {
+    // Pressable supports: active, hover, focus, disabled
+    const pressableModifiers: Array<"active" | "hover" | "focus" | "disabled"> = [
+      "active",
+      "hover",
+      "focus",
+      "disabled",
+    ];
+
+    const expectedMapping = {
+      active: "pressed",
+      hover: "hovered",
+      focus: "focused",
+      disabled: "disabled",
+    };
+
+    for (const modifier of pressableModifiers) {
+      expect(getStatePropertyForModifier(modifier)).toBe(expectedMapping[modifier]);
+    }
+  });
+
+  it("should handle all TextInput modifier states", () => {
+    // TextInput supports: focus, disabled, placeholder
+    // Note: placeholder doesn't have a state property (it's a prop, not state)
+    const textInputModifiers: Array<"focus" | "disabled"> = ["focus", "disabled"];
+
+    const expectedMapping = {
+      focus: "focused",
+      disabled: "disabled",
+    };
+
+    for (const modifier of textInputModifiers) {
+      expect(getStatePropertyForModifier(modifier)).toBe(expectedMapping[modifier]);
+    }
+  });
+});
+
+describe("Integration - Real-world scenarios", () => {
+  it("should correctly identify modifiers for a Pressable button", () => {
+    const element = createJSXElement(
+      '<Pressable className="active:bg-blue-700 hover:bg-blue-600 disabled:bg-gray-300" />',
+    );
+    const result = getComponentModifierSupport(element, t);
+
+    expect(result).not.toBeNull();
+    expect(result?.component).toBe("Pressable");
+
+    // Verify all used modifiers are supported
+    expect(result?.supportedModifiers).toContain("active");
+    expect(result?.supportedModifiers).toContain("hover");
+    expect(result?.supportedModifiers).toContain("disabled");
+  });
+
+  it("should correctly identify modifiers for a TextInput field", () => {
+    const element = createJSXElement(
+      '<TextInput className="focus:border-blue-500 disabled:bg-gray-100 placeholder:text-gray-400" />',
+    );
+    const result = getComponentModifierSupport(element, t);
+
+    expect(result).not.toBeNull();
+    expect(result?.component).toBe("TextInput");
+
+    // Verify all used modifiers are supported
+    expect(result?.supportedModifiers).toContain("focus");
+    expect(result?.supportedModifiers).toContain("disabled");
+    expect(result?.supportedModifiers).toContain("placeholder");
+  });
+
+  it("should handle namespaced components from imports", () => {
+    const element = createJSXElement('<RN.Pressable className="active:opacity-80" />');
+    const result = getComponentModifierSupport(element, t);
+
+    expect(result).not.toBeNull();
+    expect(result?.component).toBe("Pressable");
+    expect(result?.supportedModifiers).toContain("active");
+  });
+
+  it("should return null for unsupported components with modifiers", () => {
+    const element = createJSXElement('<View className="hover:bg-blue-500" />');
+    const result = getComponentModifierSupport(element, t);
+
+    // View doesn't support modifiers
+    expect(result).toBeNull();
+  });
+
+  it("should map all Pressable modifiers to correct state properties", () => {
+    const element = createJSXElement("<Pressable />");
+    const result = getComponentModifierSupport(element, t);
+
+    expect(result).not.toBeNull();
+
+    // Test each supported modifier maps correctly
+    const modifiers = result?.supportedModifiers as Array<"active" | "hover" | "focus" | "disabled">;
+    for (const modifier of modifiers) {
+      const stateProp = getStatePropertyForModifier(modifier);
+      expect(stateProp).toBeTruthy();
+      expect(typeof stateProp).toBe("string");
+    }
+
+    // Verify the mappings
+    expect(getStatePropertyForModifier("active")).toBe("pressed");
+    expect(getStatePropertyForModifier("hover")).toBe("hovered");
+    expect(getStatePropertyForModifier("focus")).toBe("focused");
+    expect(getStatePropertyForModifier("disabled")).toBe("disabled");
+  });
+
+  it("should map all TextInput modifiers to correct state properties", () => {
+    const element = createJSXElement("<TextInput />");
+    const result = getComponentModifierSupport(element, t);
+
+    expect(result).not.toBeNull();
+
+    // Filter out placeholder as it doesn't have a state property
+    const stateModifiers = result?.supportedModifiers.filter((m) => m !== "placeholder") as Array<
+      "focus" | "disabled"
+    >;
+
+    for (const modifier of stateModifiers) {
+      const stateProp = getStatePropertyForModifier(modifier);
+      expect(stateProp).toBeTruthy();
+      expect(typeof stateProp).toBe("string");
+    }
+
+    // Verify the mappings
+    expect(getStatePropertyForModifier("focus")).toBe("focused");
+    expect(getStatePropertyForModifier("disabled")).toBe("disabled");
+  });
+});

package/src/parser/colors.test.ts

@@ -168,6 +168,38 @@ describe("parseColor - custom colors", () => {
     expect(parseColor("bg-blue-500", overrideColors)).toEqual({ backgroundColor: "#FF0000" });
   });
 
+  it("should support custom colors with DEFAULT key from tailwind.config", () => {
+    // Simulates what flattenColors() produces from:
+    // { primary: { DEFAULT: "#1bacb5", 50: "#eefdfd", ... } }
+    const customColorsWithDefault = {
+      primary: "#1bacb5", // DEFAULT becomes the parent key
+      "primary-50": "#eefdfd",
+      "primary-100": "#d4f9f9",
+      "primary-500": "#1bacb5",
+      "primary-900": "#1e4f5b",
+    };
+
+    // Test that bg-primary uses the DEFAULT value
+    expect(parseColor("bg-primary", customColorsWithDefault)).toEqual({
+      backgroundColor: "#1bacb5",
+    });
+
+    // Test that bg-primary-50 uses the shade value
+    expect(parseColor("bg-primary-50", customColorsWithDefault)).toEqual({
+      backgroundColor: "#eefdfd",
+    });
+
+    // Test with text colors
+    expect(parseColor("text-primary", customColorsWithDefault)).toEqual({
+      color: "#1bacb5",
+    });
+
+    // Test with border colors
+    expect(parseColor("border-primary", customColorsWithDefault)).toEqual({
+      borderColor: "#1bacb5",
+    });
+  });
+
   it("should fallback to preset colors when custom color not found", () => {
     expect(parseColor("bg-red-500", customColors)).toEqual({ backgroundColor: COLORS["red-500"] });
   });

package/src/parser/index.ts

@@ -42,7 +42,7 @@ export function parseClass(cls: string, customColors?: Record<string, string>):
   // Try each parser in order
   // Note: parseBorder must come before parseColor to avoid border-[3px] being parsed as a color
   // parseColor gets custom colors, others don't need it
-  const parsers: ((cls: string) => StyleObject | null)[] = [
+  const parsers: Array<(cls: string) => StyleObject | null> = [
     parseSpacing,
     parseBorder,
     (cls: string) => parseColor(cls, customColors),

package/src/utils/flattenColors.test.ts

@@ -358,4 +358,104 @@ describe("flattenColors", () => {
 
     expect(keys).toEqual(["z", "a", "m"]);
   });
+
+  it("should handle DEFAULT key in color scale objects", () => {
+    const colors = {
+      primary: {
+        "50": "#eefdfd",
+        "100": "#d4f9f9",
+        "200": "#aef2f3",
+        "500": "#1bacb5",
+        "900": "#1e4f5b",
+        DEFAULT: "#1bacb5",
+      },
+    };
+
+    expect(flattenColors(colors)).toEqual({
+      primary: "#1bacb5", // DEFAULT becomes the parent key
+      "primary-50": "#eefdfd",
+      "primary-100": "#d4f9f9",
+      "primary-200": "#aef2f3",
+      "primary-500": "#1bacb5",
+      "primary-900": "#1e4f5b",
+    });
+  });
+
+  it("should handle DEFAULT key with multiple color scales", () => {
+    const colors = {
+      primary: {
+        DEFAULT: "#1bacb5",
+        "500": "#1bacb5",
+      },
+      secondary: {
+        DEFAULT: "#ff6b6b",
+        "500": "#ff6b6b",
+      },
+    };
+
+    expect(flattenColors(colors)).toEqual({
+      primary: "#1bacb5",
+      "primary-500": "#1bacb5",
+      secondary: "#ff6b6b",
+      "secondary-500": "#ff6b6b",
+    });
+  });
+
+  it("should handle DEFAULT key in nested structures", () => {
+    const colors = {
+      brand: {
+        primary: {
+          DEFAULT: "#1bacb5",
+          light: "#d4f9f9",
+          dark: "#0e343e",
+        },
+      },
+    };
+
+    expect(flattenColors(colors)).toEqual({
+      "brand-primary": "#1bacb5", // DEFAULT uses parent key
+      "brand-primary-light": "#d4f9f9",
+      "brand-primary-dark": "#0e343e",
+    });
+  });
+
+  it("should handle DEFAULT at top level (edge case)", () => {
+    const colors = {
+      DEFAULT: "#000000",
+      primary: "#ff0000",
+    };
+
+    expect(flattenColors(colors)).toEqual({
+      DEFAULT: "#000000", // Top-level DEFAULT kept as-is (no parent)
+      primary: "#ff0000",
+    });
+  });
+
+  it("should handle mixed DEFAULT and regular keys", () => {
+    const colors = {
+      gray: {
+        "50": "#f9fafb",
+        "100": "#f3f4f6",
+        DEFAULT: "#6b7280",
+        "500": "#6b7280",
+        "900": "#111827",
+      },
+      white: "#ffffff",
+      brand: {
+        DEFAULT: "#ff6b6b",
+        accent: "#4ecdc4",
+      },
+    };
+
+    expect(flattenColors(colors)).toEqual({
+      "gray-50": "#f9fafb",
+      "gray-100": "#f3f4f6",
+      gray: "#6b7280", // DEFAULT becomes parent key
+      "gray-500": "#6b7280",
+      "gray-900": "#111827",
+      white: "#ffffff",
+      brand: "#ff6b6b", // DEFAULT becomes parent key
+      "brand-accent": "#4ecdc4",
+    });
+  });
 });

package/src/utils/flattenColors.ts

@@ -8,6 +8,7 @@ type NestedColors = {
 /**
  * Flatten nested color objects into flat key-value map
  * Example: { brand: { light: '#fff', dark: '#000' } } => { 'brand-light': '#fff', 'brand-dark': '#000' }
+ * Special handling for DEFAULT: { primary: { DEFAULT: '#000', 500: '#333' } } => { 'primary': '#000', 'primary-500': '#333' }
  *
  * @param colors - Nested color object where values can be strings or objects
  * @param prefix - Optional prefix for nested keys (used for recursion)
@@ -17,7 +18,8 @@ export function flattenColors(colors: NestedColors, prefix = ""): Record<string,
   const result: Record<string, string> = {};
 
   for (const [key, value] of Object.entries(colors)) {
-    const newKey = prefix ? `${prefix}-${key}` : key;
+    // Special handling for DEFAULT key - use parent key without suffix
+    const newKey = key === "DEFAULT" && prefix ? prefix : prefix ? `${prefix}-${key}` : key;
 
     if (typeof value === "string") {
       result[newKey] = value;