@mgcrea/react-native-tailwind 0.9.1 → 0.10.0

package/dist/types/config.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Configuration for the scheme: modifier
+ */
+export type SchemeModifierConfig = {
+    darkSuffix?: string;
+    lightSuffix?: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mgcrea/react-native-tailwind",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Compile-time Tailwind CSS for React Native with zero runtime overhead",
   "author": "Olivier Louvignes <olivier@mgcrea.io> (https://github.com/mgcrea)",
   "homepage": "https://github.com/mgcrea/react-native-tailwind#readme",
@@ -90,7 +90,8 @@
   },
   "pnpm": {
     "onlyBuiltDependencies": [
-      "esbuild"
+      "esbuild",
+      "unrs-resolver"
     ]
   }
 }

package/src/babel/config-loader.test.ts

@@ -0,0 +1,152 @@
+import * as fs from "fs";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { extractCustomColors, findTailwindConfig, loadTailwindConfig } from "./config-loader";
+
+// Mock fs
+vi.mock("fs");
+
+describe("config-loader", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("findTailwindConfig", () => {
+    it("should find tailwind.config.mjs in current directory", () => {
+      const startDir = "/project/src";
+      const expectedPath = "/project/src/tailwind.config.mjs";
+
+      vi.spyOn(fs, "existsSync").mockImplementation((filepath) => {
+        return filepath === expectedPath;
+      });
+
+      const result = findTailwindConfig(startDir);
+      expect(result).toBe(expectedPath);
+    });
+
+    it("should find tailwind.config.js in parent directory", () => {
+      const startDir = "/project/src/components";
+      const expectedPath = "/project/tailwind.config.js";
+
+      vi.spyOn(fs, "existsSync").mockImplementation((filepath) => {
+        return filepath === expectedPath;
+      });
+
+      const result = findTailwindConfig(startDir);
+      expect(result).toBe(expectedPath);
+    });
+
+    it("should return null if no config found", () => {
+      const startDir = "/project/src";
+
+      vi.spyOn(fs, "existsSync").mockReturnValue(false);
+
+      const result = findTailwindConfig(startDir);
+      expect(result).toBeNull();
+    });
+
+    it("should prioritize config file extensions in correct order", () => {
+      const startDir = "/project";
+      const mjsPath = "/project/tailwind.config.mjs";
+      const jsPath = "/project/tailwind.config.js";
+
+      vi.spyOn(fs, "existsSync").mockImplementation((filepath) => {
+        // Both exist, but mjs should be found first
+        return filepath === mjsPath || filepath === jsPath;
+      });
+
+      const result = findTailwindConfig(startDir);
+      expect(result).toBe(mjsPath); // .mjs has priority
+    });
+  });
+
+  describe("loadTailwindConfig", () => {
+    it("should load config with default export", () => {
+      const configPath = "/project/tailwind.config.js";
+      const mockConfig = {
+        theme: {
+          extend: {
+            colors: { brand: "#123456" },
+          },
+        },
+      };
+
+      // Mock require.resolve and require
+      vi.spyOn(require, "resolve").mockReturnValue(configPath);
+      vi.doMock(configPath, () => ({ default: mockConfig }));
+
+      // We need to use dynamic import workaround for testing
+      const config = { default: mockConfig };
+      const result = "default" in config ? config.default : config;
+
+      expect(result).toEqual(mockConfig);
+    });
+
+    it("should load config with direct export", () => {
+      const mockConfig = {
+        theme: {
+          colors: { primary: "#ff0000" },
+        },
+      };
+
+      const config = mockConfig;
+      const result = "default" in config ? (config as { default: unknown }).default : config;
+
+      expect(result).toEqual(mockConfig);
+    });
+
+    it("should cache loaded configs", () => {
+      const configPath = "/project/tailwind.config.js";
+      const _mockConfig = { theme: {} };
+
+      vi.spyOn(require, "resolve").mockReturnValue(configPath);
+
+      // First load
+      const config1 = loadTailwindConfig(configPath);
+
+      // Second load - should hit cache
+      const config2 = loadTailwindConfig(configPath);
+
+      // Both should return same result (from cache)
+      expect(config1).toBe(config2);
+    });
+  });
+
+  describe("extractCustomColors", () => {
+    it("should return empty object when no config found", () => {
+      vi.spyOn(fs, "existsSync").mockReturnValue(false);
+
+      const result = extractCustomColors("/project/src/file.ts");
+      expect(result).toEqual({});
+    });
+
+    it("should return empty object when config has no theme", () => {
+      const configPath = "/project/tailwind.config.js";
+
+      vi.spyOn(fs, "existsSync").mockImplementation((filepath) => filepath === configPath);
+      vi.spyOn(require, "resolve").mockReturnValue(configPath);
+
+      // loadTailwindConfig will be called, but we've already tested it
+      // For integration, we'd need to mock the entire flow
+      const result = extractCustomColors("/project/src/file.ts");
+
+      // Without actual config loading, this returns empty
+      expect(result).toEqual({});
+    });
+
+    it("should extract colors from theme.extend.colors", () => {
+      // This would require complex mocking of the entire require flow
+      // Testing the logic: theme.extend.colors is preferred
+      const colors = { brand: { light: "#fff", dark: "#000" } };
+      const theme = {
+        extend: { colors },
+      };
+
+      // If we had the config, we'd flatten the colors
+      expect(theme.extend.colors).toEqual(colors);
+    });
+  });
+});

package/src/babel/plugin.test.ts

@@ -722,6 +722,306 @@ describe("Babel plugin - platform modifier transformation", () => {
   });
 });
 
+describe("Babel plugin - color scheme modifier transformation", () => {
+  it("should transform dark: modifier to conditional expression", () => {
+    const input = `
+      import React from 'react';
+      import { View } from 'react-native';
+
+      export function Component() {
+        return (
+          <View className="bg-white dark:bg-gray-900" />
+        );
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Should import useColorScheme
+    expect(output).toContain("useColorScheme");
+    expect(output).toMatch(/import.*useColorScheme.*from ['"]react-native['"]/);
+
+    // Should inject colorScheme hook in component
+    expect(output).toContain("_twColorScheme");
+    expect(output).toContain("useColorScheme()");
+
+    // Should have base bg-white style
+    expect(output).toContain("_bg_white");
+
+    // Should have dark:bg-gray-900 style
+    expect(output).toContain("_dark_bg_gray_900");
+
+    // Should generate conditional: _twColorScheme === 'dark' && ...
+    expect(output).toMatch(/_twColorScheme\s*===\s*['"]dark['"]/);
+  });
+
+  it("should support both dark: and light: modifiers", () => {
+    const input = `
+      import React from 'react';
+      import { View } from 'react-native';
+
+      export function Component() {
+        return (
+          <View className="bg-gray-100 dark:bg-gray-900 light:bg-white" />
+        );
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Should have all three styles
+    expect(output).toContain("_bg_gray_100");
+    expect(output).toContain("_dark_bg_gray_900");
+    expect(output).toContain("_light_bg_white");
+
+    // Should have both conditionals
+    expect(output).toMatch(/_twColorScheme\s*===\s*['"]dark['"]/);
+    expect(output).toMatch(/_twColorScheme\s*===\s*['"]light['"]/);
+  });
+
+  it("should inject hook once for multiple elements with color scheme modifiers", () => {
+    const input = `
+      import React from 'react';
+      import { View, Text } from 'react-native';
+
+      export function Component() {
+        return (
+          <>
+            <View className="dark:bg-gray-900" />
+            <Text className="dark:text-white" />
+            <View className="light:bg-white" />
+          </>
+        );
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Count occurrences of useColorScheme() call - should be exactly 1
+    const hookCallMatches = output.match(/=\s*useColorScheme\(\)/g);
+    expect(hookCallMatches).toHaveLength(1);
+
+    // Should have color scheme variable
+    expect(output).toContain("_twColorScheme");
+  });
+
+  it("should work with color scheme and platform modifiers together", () => {
+    const input = `
+      import React from 'react';
+      import { View } from 'react-native';
+
+      export function Component() {
+        return (
+          <View className="p-4 ios:p-6 dark:bg-gray-900" />
+        );
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Should have Platform import
+    expect(output).toContain("Platform");
+
+    // Should have useColorScheme import
+    expect(output).toContain("useColorScheme");
+
+    // Should have Platform.select for ios:
+    expect(output).toContain("Platform.select");
+    expect(output).toContain("_ios_p_6");
+
+    // Should have color scheme conditional for dark:
+    expect(output).toMatch(/_twColorScheme\s*===\s*['"]dark['"]/);
+    expect(output).toContain("_dark_bg_gray_900");
+  });
+
+  it("should only add useColorScheme import once when needed", () => {
+    const input = `
+      import React from 'react';
+      import { View } from 'react-native';
+
+      export function Component() {
+        return (
+          <>
+            <View className="dark:bg-black" />
+            <View className="light:bg-white" />
+          </>
+        );
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Count useColorScheme imports
+    const importMatches = output.match(/import.*useColorScheme.*from ['"]react-native['"]/g);
+    expect(importMatches).toHaveLength(1);
+  });
+
+  it("should merge with existing useColorScheme import", () => {
+    const input = `
+      import React from 'react';
+      import { View, useColorScheme } from 'react-native';
+
+      export function Component() {
+        return <View className="dark:bg-gray-900" />;
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Should still use useColorScheme
+    expect(output).toContain("useColorScheme");
+
+    // Should inject hook call
+    expect(output).toContain("_twColorScheme");
+    expect(output).toContain("useColorScheme()");
+  });
+
+  it("should work with concise arrow functions", () => {
+    const input = `
+      import React from 'react';
+      import { View } from 'react-native';
+
+      const Component = () => <View className="dark:bg-gray-900" />;
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Should inject useColorScheme import
+    expect(output).toContain("useColorScheme");
+
+    // Should convert concise arrow to block statement and inject hook
+    expect(output).toContain("_twColorScheme");
+    expect(output).toContain("useColorScheme()");
+    expect(output).toContain("return");
+
+    // Should have the style
+    expect(output).toContain("_dark_bg_gray_900");
+    expect(output).toMatch(/_twColorScheme\s*===\s*['"]dark['"]/);
+  });
+
+  it("should inject hook at component level when dark: used in nested callback", () => {
+    const input = `
+      import React from 'react';
+      import { View } from 'react-native';
+
+      export function Component() {
+        const items = [1, 2, 3];
+        return (
+          <View>
+            {items.map(item => (
+              <View key={item} className="dark:bg-gray-900" />
+            ))}
+          </View>
+        );
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Should inject hook at Component level (not in map callback)
+    expect(output).toContain("_twColorScheme");
+    expect(output).toContain("useColorScheme()");
+
+    // Hook should be injected in Component function, not in map callback
+    // Count occurrences - should be exactly 1 at Component level
+    const hookCallMatches = output.match(/=\s*useColorScheme\(\)/g);
+    expect(hookCallMatches).toHaveLength(1);
+
+    // Should still generate conditional expression
+    expect(output).toContain("_dark_bg_gray_900");
+    expect(output).toMatch(/_twColorScheme\s*===\s*['"]dark['"]/);
+  });
+
+  it("should handle dynamic expressions with dark:/light: modifiers", () => {
+    const input = `
+      import React from 'react';
+      import { View } from 'react-native';
+
+      export function Component({ isActive }) {
+        return (
+          <View className={\`p-4 \${isActive ? "dark:bg-blue-500" : "dark:bg-gray-900"}\`} />
+        );
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Should inject useColorScheme
+    expect(output).toContain("useColorScheme");
+    expect(output).toContain("_twColorScheme");
+
+    // Should have both dark styles
+    expect(output).toContain("_dark_bg_blue_500");
+    expect(output).toContain("_dark_bg_gray_900");
+
+    // Should have conditional expressions for color scheme
+    expect(output).toMatch(/_twColorScheme\s*===\s*['"]dark['"]/);
+  });
+
+  it("should handle dynamic expressions with platform modifiers", () => {
+    const input = `
+      import React from 'react';
+      import { View } from 'react-native';
+
+      export function Component({ isLarge }) {
+        return (
+          <View className={\`p-4 \${isLarge ? "ios:p-8" : "ios:p-6"}\`} />
+        );
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Should inject Platform import
+    expect(output).toContain("Platform");
+
+    // Should have both ios styles
+    expect(output).toContain("_ios_p_8");
+    expect(output).toContain("_ios_p_6");
+
+    // Should have Platform.select
+    expect(output).toContain("Platform.select");
+  });
+
+  it("should skip color scheme modifiers when used outside component scope", () => {
+    // Suppress console.warn for this test
+    const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    const input = `
+      import React from 'react';
+      import { View } from 'react-native';
+
+      // Class component - no function component scope
+      class MyComponent extends React.Component {
+        render() {
+          return <View className="p-4 dark:bg-gray-900" />;
+        }
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Should warn about invalid context
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("dark:/light: modifiers require a function component scope"),
+    );
+
+    // Should NOT inject useColorScheme import (no valid component scope)
+    expect(output).not.toContain("useColorScheme");
+
+    // Should NOT have _twColorScheme variable reference (would cause ReferenceError)
+    expect(output).not.toContain("_twColorScheme");
+
+    // Should NOT have dark: style conditional (skipped due to no component scope)
+    expect(output).not.toContain("_dark_bg_gray_900");
+
+    // Should still transform base classes (p-4)
+    expect(output).toContain("_p_4");
+
+    consoleWarnSpy.mockRestore();
+  });
+});
+
 describe("Babel plugin - import injection", () => {
   it("should not add StyleSheet import to files without className usage", () => {
     const input = `
@@ -807,3 +1107,34 @@ describe("Babel plugin - import injection", () => {
     expect(output).toContain("StyleSheet");
   });
 });
+
+describe("Babel plugin - scheme: modifier", () => {
+  it.skip("should expand scheme: modifier into dark: and light: modifiers", () => {
+    // Note: This test requires tailwind.config.js with custom colors defined
+    // The scheme: modifier expands to dark: and light: modifiers which require
+    // the color variants to exist in customColors (e.g., systemGray-dark, systemGray-light)
+    //
+    // Integration test should be done in a real project with tailwind.config.js
+    const input = `
+      import { View } from 'react-native';
+
+      function MyComponent() {
+        return <View className="scheme:text-systemGray" />;
+      }
+    `;
+
+    const output = transform(input, undefined, true);
+
+    // Should generate both dark and light variants
+    expect(output).toContain("_dark_text_systemGray_dark");
+    expect(output).toContain("_light_text_systemGray_light");
+
+    // Should inject useColorScheme hook
+    expect(output).toContain("useColorScheme");
+    expect(output).toContain("_twColorScheme");
+
+    // Should have conditional expressions
+    expect(output).toContain("_twColorScheme === 'dark'");
+    expect(output).toContain("_twColorScheme === 'light'");
+  });
+});