@strata-game-library/react-native-plugin 1.0.0

package/README.md

@@ -0,0 +1,61 @@
+# @strata/react-native-plugin
+
+[![npm version](https://img.shields.io/npm/v/@strata/react-native-plugin.svg)](https://www.npmjs.com/package/@strata/react-native-plugin)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+React Native plugin for [Strata 3D](https://strata.game) - cross-platform input, device detection, and haptics for mobile games.
+
+## 📚 Documentation
+
+**Full documentation is available at [strata.game/mobile/react-native](https://strata.game/mobile/react-native/)**
+
+---
+
+## 🏢 Enterprise Context
+
+**Strata** is the Games & Procedural division of the [jbcom enterprise](https://jbcom.github.io). This plugin is part of a coherent suite of specialized tools, sharing a unified design system and interconnected with sibling organizations like [Agentic](https://agentic.dev) and [Extended Data](https://extendeddata.dev).
+
+## Features
+
+- **Device Detection** - Identify device type, platform, and performance capabilities
+- **Input Handling** - Unified touch input handling with `StrataInputProvider`
+- **Haptic Feedback** - Cross-platform vibration with intensity control
+- **Safe Area Insets** - Native safe area detection for notches
+- **Orientation** - Get and set screen orientation
+- **Performance Mode** - Detect low power mode and hardware levels
+
+## Installation
+
+```bash
+npm install @strata/react-native-plugin
+cd ios && pod install
+```
+
+## Quick Start
+
+```tsx
+import { useDevice, useInput, useHaptics } from '@strata/react-native-plugin';
+
+function Game() {
+  const device = useDevice();
+  const input = useInput();
+  const { trigger } = useHaptics();
+  
+  return (
+    <View>
+      <Text>Platform: {device.platform}</Text>
+      <Button onPress={() => trigger({ intensity: 'medium' })} />
+    </View>
+  );
+}
+```
+
+## Related
+
+- [Strata Documentation](https://strata.game) - Full documentation
+- [Strata Core](https://github.com/strata-game-library/core) - Main library
+- [Capacitor Plugin](https://github.com/strata-game-library/capacitor-plugin) - Capacitor version
+
+## License
+
+MIT © [Jon Bogaty](https://github.com/jbcom)

package/android/build.gradle

@@ -0,0 +1,66 @@
+buildscript {
+    ext.safeExtGet = {prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath "com.android.tools.build:gradle:8.1.1"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.10"
+    }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+def getExtOrDefault(name) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["StrataReactNativePlugin_" + name]
+}
+
+android {
+    namespace "com.jbcom.strata"
+    compileSdkVersion getExtOrDefault("compileSdkVersion") ?: 34
+
+    defaultConfig {
+        minSdkVersion getExtOrDefault("minSdkVersion") ?: 21
+        targetSdkVersion getExtOrDefault("targetSdkVersion") ?: 34
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    lintOptions {
+        disable "GradleCompatible"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
+repositories {
+    mavenLocal()
+    maven {
+        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+        url("$projectDir/../node_modules/react-native/android")
+    }
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    //noinspection GradleDynamicVersion
+    implementation "com.facebook.react:react-android:+"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:1.8.10"
+    implementation "androidx.core:core-ktx:1.9.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.jbcom.strata">
+
+    <uses-permission android:name="android.permission.VIBRATE" />
+
+</manifest>

package/android/src/main/java/com/jbcom/strata/StrataModule.kt

@@ -0,0 +1,353 @@
+package com.jbcom.strata
+
+import android.content.Context
+import android.content.res.Configuration
+import android.content.pm.ActivityInfo
+import android.os.Build
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
+import android.os.PowerManager
+import android.app.ActivityManager
+import android.view.InputDevice
+import android.view.WindowManager
+import android.view.KeyEvent
+import android.view.MotionEvent
+import android.view.View
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class StrataModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
+
+    private var isListening = false
+    private val buttons = Arguments.createMap()
+    private val leftStick = Arguments.createMap()
+    private val rightStick = Arguments.createMap()
+    private val triggers = Arguments.createMap()
+
+    init {
+        reactContext.addLifecycleEventListener(this)
+        resetGamepadState()
+    }
+
+    private fun resetGamepadState() {
+        leftStick.putDouble("x", 0.0)
+        leftStick.putDouble("y", 0.0)
+        rightStick.putDouble("x", 0.0)
+        rightStick.putDouble("y", 0.0)
+        triggers.putDouble("left", 0.0)
+        triggers.putDouble("right", 0.0)
+        
+        // Initialize buttons (common ones)
+        val buttonList = listOf("a", "b", "x", "y", "l1", "r1", "l2", "r2", "start", "select", "dpadUp", "dpadDown", "dpadLeft", "dpadRight")
+        for (button in buttonList) {
+            buttons.putBoolean(button, false)
+        }
+    }
+
+    override fun getName(): String {
+        return "StrataReactNativePlugin"
+    }
+
+    override fun getConstants(): Map<String, Any>? {
+        val constants = mutableMapOf<String, Any>()
+        constants["platform"] = "android"
+        return constants
+    }
+
+    override fun onHostResume() {
+        startListening()
+    }
+
+    override fun onHostPause() {
+        stopListening()
+    }
+
+    override fun onHostDestroy() {
+        stopListening()
+    }
+
+    private fun startListening() {
+        if (isListening) return
+        isListening = true
+    }
+
+    private fun stopListening() {
+        isListening = false
+    }
+
+    @ReactMethod
+    fun getDeviceProfile(promise: Promise) {
+        try {
+            val context = reactApplicationContext
+            val metrics = context.resources.displayMetrics
+            val configuration = context.resources.configuration
+
+            val profile = Arguments.createMap()
+            
+            // Device Type
+            val deviceType = when {
+                isFoldable() -> "foldable"
+                (configuration.screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK) >= Configuration.SCREENLAYOUT_SIZE_LARGE -> "tablet"
+                else -> "mobile"
+            }
+            profile.putString("deviceType", deviceType)
+            profile.putString("platform", "android")
+            
+            // Input Mode (Default to touch, check for gamepads later)
+            profile.putString("inputMode", if (hasGamepadConnected()) "gamepad" else "touch")
+            
+            // Orientation
+            val orientation = if (configuration.orientation == Configuration.ORIENTATION_LANDSCAPE) "landscape" else "portrait"
+            profile.putString("orientation", orientation)
+            
+            profile.putBoolean("hasTouch", context.packageManager.hasSystemFeature("android.hardware.touchscreen"))
+            profile.putBoolean("hasGamepad", hasGamepadConnected())
+            
+            profile.putDouble("screenWidth", metrics.widthPixels.toDouble() / metrics.density)
+            profile.putDouble("screenHeight", metrics.heightPixels.toDouble() / metrics.density)
+            profile.putDouble("pixelRatio", metrics.density.toDouble())
+
+            // Safe Area Insets
+            profile.putMap("safeAreaInsets", getSafeAreaInsetsMap())
+
+            promise.resolve(profile)
+        } catch (e: Exception) {
+            promise.reject("ERR_DEVICE_PROFILE", e.message)
+        }
+    }
+
+    // Compatibility method for getDeviceInfo
+    @ReactMethod
+    fun getDeviceInfo(promise: Promise) {
+        getDeviceProfile(promise)
+    }
+
+    @ReactMethod
+    fun triggerHaptics(options: ReadableMap, promise: Promise) {
+        val vibrator = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val vibratorManager = reactApplicationContext.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
+            vibratorManager.defaultVibrator
+        } else {
+            @Suppress("DEPRECATION")
+            reactApplicationContext.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+        }
+
+        if (!vibrator.hasVibrator()) {
+            promise.resolve(false)
+            return
+        }
+
+        val duration = if (options.hasKey("duration")) options.getInt("duration").toLong() else 50L
+        val intensity = if (options.hasKey("customIntensity")) (options.getDouble("customIntensity") * 255).toInt() else 128
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            vibrator.vibrate(VibrationEffect.createOneShot(duration, intensity.coerceIn(1, 255)))
+        } else {
+            @Suppress("DEPRECATION")
+            vibrator.vibrate(duration)
+        }
+        promise.resolve(true)
+    }
+
+    // Compatibility method for triggerHaptic(intensity)
+    @ReactMethod
+    fun triggerHaptic(intensity: String, promise: Promise) {
+        val options = Arguments.createMap()
+        options.putString("intensity", intensity)
+        when (intensity) {
+            "light" -> options.putDouble("customIntensity", 0.3)
+            "medium" -> options.putDouble("customIntensity", 0.6)
+            "heavy" -> options.putDouble("customIntensity", 1.0)
+        }
+        triggerHaptics(options, promise)
+    }
+
+    @ReactMethod
+    @Synchronized
+    fun getInputSnapshot(promise: Promise) {
+        val snapshot = Arguments.createMap()
+        snapshot.putDouble("timestamp", System.currentTimeMillis().toDouble())
+        
+        val snapshotButtons = Arguments.createMap()
+        val buttonsIter = buttons.keySetIterator()
+        while (buttonsIter.hasNextKey()) {
+            val key = buttonsIter.nextKey()
+            snapshotButtons.putBoolean(key, buttons.getBoolean(key))
+        }
+        snapshot.putMap("buttons", snapshotButtons)
+
+        val snapshotLeftStick = Arguments.createMap()
+        snapshotLeftStick.putDouble("x", leftStick.getDouble("x"))
+        snapshotLeftStick.putDouble("y", leftStick.getDouble("y"))
+        snapshot.putMap("leftStick", snapshotLeftStick)
+
+        val snapshotRightStick = Arguments.createMap()
+        snapshotRightStick.putDouble("x", rightStick.getDouble("x"))
+        snapshotRightStick.putDouble("y", rightStick.getDouble("y"))
+        snapshot.putMap("rightStick", snapshotRightStick)
+
+        val snapshotTriggers = Arguments.createMap()
+        snapshotTriggers.putDouble("left", triggers.getDouble("left"))
+        snapshotTriggers.putDouble("right", triggers.getDouble("right"))
+        snapshot.putMap("triggers", snapshotTriggers)
+        
+        val gamepads = Arguments.createArray()
+        val deviceIds = InputDevice.getDeviceIds()
+        for (deviceId in deviceIds) {
+            val device = InputDevice.getDevice(deviceId)
+            if (device != null && (device.sources and InputDevice.SOURCE_GAMEPAD == InputDevice.SOURCE_GAMEPAD ||
+                device.sources and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK)) {
+                gamepads.pushInt(deviceId)
+            }
+        }
+        
+        snapshot.putArray("connectedGamepads", gamepads)
+        promise.resolve(snapshot)
+    }
+
+    @ReactMethod
+    fun setOrientation(orientation: String) {
+        val activity = currentActivity ?: return
+        val orientationConstant = when (orientation) {
+            "portrait" -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+            "landscape" -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+            else -> ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+        }
+        activity.requestedOrientation = orientationConstant
+    }
+
+    @ReactMethod
+    fun getPerformanceMode(promise: Promise) {
+        val map = Arguments.createMap()
+        val context = reactApplicationContext
+        
+        val powerManager = context.getSystemService(Context.POWER_SERVICE) as? PowerManager
+        val isLowPowerMode = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            powerManager?.isPowerSaveMode ?: false
+        } else false
+
+        val mi = ActivityManager.MemoryInfo()
+        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+        activityManager?.getMemoryInfo(mi)
+        
+        val mode = when {
+            isLowPowerMode || mi.totalMem < 2L * 1024 * 1024 * 1024 -> "low"
+            mi.totalMem < 4L * 1024 * 1024 * 1024 -> "medium"
+            else -> "high"
+        }
+
+        map.putString("mode", mode)
+        map.putBoolean("isLowPowerMode", isLowPowerMode)
+        map.putDouble("totalMemory", mi.totalMem.toDouble())
+        promise.resolve(map)
+    }
+
+    @ReactMethod
+    fun getSafeAreaInsets(promise: Promise) {
+        promise.resolve(getSafeAreaInsetsMap())
+    }
+
+    // Methods to be called from MainActivity to update state
+    @Synchronized
+    fun handleKeyEvent(event: KeyEvent) {
+        val isDown = event.action == KeyEvent.ACTION_DOWN
+        val button = when (event.keyCode) {
+            KeyEvent.KEYCODE_BUTTON_A -> "a"
+            KeyEvent.KEYCODE_BUTTON_B -> "b"
+            KeyEvent.KEYCODE_BUTTON_X -> "x"
+            KeyEvent.KEYCODE_BUTTON_Y -> "y"
+            KeyEvent.KEYCODE_BUTTON_L1 -> "l1"
+            KeyEvent.KEYCODE_BUTTON_R1 -> "r1"
+            KeyEvent.KEYCODE_BUTTON_L2 -> "l2"
+            KeyEvent.KEYCODE_BUTTON_R2 -> "r2"
+            KeyEvent.KEYCODE_BUTTON_START -> "start"
+            KeyEvent.KEYCODE_BUTTON_SELECT -> "select"
+            KeyEvent.KEYCODE_DPAD_UP -> "dpadUp"
+            KeyEvent.KEYCODE_DPAD_DOWN -> "dpadDown"
+            KeyEvent.KEYCODE_DPAD_LEFT -> "dpadLeft"
+            KeyEvent.KEYCODE_DPAD_RIGHT -> "dpadRight"
+            else -> null
+        }
+        button?.let { buttons.putBoolean(it, isDown) }
+    }
+
+    @Synchronized
+    fun handleMotionEvent(event: MotionEvent) {
+        if (event.source and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK &&
+            event.action == MotionEvent.ACTION_MOVE) {
+            
+            leftStick.putDouble("x", event.getAxisValue(MotionEvent.AXIS_X).toDouble())
+            leftStick.putDouble("y", event.getAxisValue(MotionEvent.AXIS_Y).toDouble())
+            
+            rightStick.putDouble("x", event.getAxisValue(MotionEvent.AXIS_Z).toDouble())
+            rightStick.putDouble("y", event.getAxisValue(MotionEvent.AXIS_RZ).toDouble())
+            
+            triggers.putDouble("left", event.getAxisValue(MotionEvent.AXIS_BRAKE).toDouble())
+            triggers.putDouble("right", event.getAxisValue(MotionEvent.AXIS_GAS).toDouble())
+        }
+    }
+
+    private fun isFoldable(): Boolean {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            return reactApplicationContext.packageManager.hasSystemFeature("android.hardware.sensor.hinge_angle")
+        }
+        return false
+    }
+
+    private fun hasGamepadConnected(): Boolean {
+        val deviceIds = InputDevice.getDeviceIds()
+        for (deviceId in deviceIds) {
+            val device = InputDevice.getDevice(deviceId)
+            if (device != null) {
+                val sources = device.sources
+                if (sources and InputDevice.SOURCE_GAMEPAD == InputDevice.SOURCE_GAMEPAD ||
+                    sources and InputDevice.SOURCE_JOYSTICK == InputDevice.SOURCE_JOYSTICK) {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+
+    private fun getSafeAreaInsetsMap(): ReadableMap {
+        val insetsMap = Arguments.createMap()
+        val density = reactApplicationContext.resources.displayMetrics.density
+        val activity = reactApplicationContext.currentActivity
+        
+        var insetsApplied = false
+        
+        if (activity != null) {
+            val windowInsets = ViewCompat.getRootWindowInsets(activity.window.decorView)
+            if (windowInsets != null) {
+                val cutoutInsets = windowInsets.getInsets(WindowInsetsCompat.Type.displayCutout())
+                insetsMap.putDouble("top", cutoutInsets.top.toDouble() / density)
+                insetsMap.putDouble("right", cutoutInsets.right.toDouble() / density)
+                insetsMap.putDouble("bottom", cutoutInsets.bottom.toDouble() / density)
+                insetsMap.putDouble("left", cutoutInsets.left.toDouble() / density)
+                insetsApplied = true
+            }
+        }
+        
+        if (!insetsApplied || insetsMap.getDouble("top") == 0.0) {
+            val resourceId = reactApplicationContext.resources.getIdentifier("status_bar_height", "dimen", "android")
+            val statusBarHeight = if (resourceId > 0) {
+                reactApplicationContext.resources.getDimensionPixelSize(resourceId).toDouble() / density
+            } else {
+                0.0
+            }
+            if (!insetsApplied) {
+                insetsMap.putDouble("top", statusBarHeight)
+                insetsMap.putDouble("right", 0.0)
+                insetsMap.putDouble("bottom", 0.0)
+                insetsMap.putDouble("left", 0.0)
+            } else if (insetsMap.getDouble("top") == 0.0) {
+                insetsMap.putDouble("top", statusBarHeight)
+            }
+        }
+        
+        return insetsMap
+    }
+}

package/android/src/main/java/com/jbcom/strata/StrataPackage.kt

@@ -0,0 +1,16 @@
+package com.jbcom.strata
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class StrataPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(StrataModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,91 @@
+import type React from 'react';
+export interface DeviceProfile {
+    deviceType: 'mobile' | 'tablet' | 'foldable' | 'desktop';
+    platform: 'ios' | 'android' | 'web';
+    inputMode: 'touch' | 'keyboard' | 'gamepad' | 'hybrid';
+    orientation: 'portrait' | 'landscape';
+    hasTouch: boolean;
+    hasGamepad: boolean;
+    screenWidth: number;
+    screenHeight: number;
+    pixelRatio: number;
+    safeAreaInsets: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    performanceMode: 'low' | 'medium' | 'high';
+}
+export interface TouchState {
+    identifier: string;
+    pageX: number;
+    pageY: number;
+    locationX: number;
+    locationY: number;
+    timestamp: number;
+}
+export interface InputSnapshot {
+    timestamp: number;
+    leftStick: {
+        x: number;
+        y: number;
+    };
+    rightStick: {
+        x: number;
+        y: number;
+    };
+    buttons: Record<string, boolean>;
+    triggers: {
+        left: number;
+        right: number;
+    };
+    touches: TouchState[];
+}
+export interface HapticsOptions {
+    type?: 'impact' | 'notification' | 'selection';
+    intensity?: 'light' | 'medium' | 'heavy' | 'success' | 'warning' | 'error';
+    customIntensity?: number;
+    duration?: number;
+    pattern?: number[];
+}
+/**
+ * Hook to get and track device information
+ */
+export declare function useDevice(): DeviceProfile;
+/**
+ * Hook to handle input state
+ */
+export declare function useInput(): InputSnapshot;
+/**
+ * A component that captures touch gestures and provides them to the game
+ */
+export declare const StrataInputProvider: React.FC<{
+    children: React.ReactNode;
+    onInput?: (snapshot: InputSnapshot) => void;
+}>;
+/**
+ * Hook for haptic feedback
+ */
+export declare function useHaptics(): {
+    trigger: (options: HapticsOptions) => Promise<void>;
+};
+/**
+ * Set screen orientation
+ */
+export declare function setOrientation(_orientation: 'portrait' | 'landscape' | 'default'): Promise<void>;
+/**
+ * Hook for control hints based on device and input
+ */
+export declare function useControlHints(): {
+    movement: string;
+    action: string;
+    camera: string;
+};
+/**
+ * Subscribe to gamepad connection events
+ */
+export declare function onGamepadUpdate(callback: (event: {
+    connected: boolean;
+}) => void): import("react-native").EmitterSubscription | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,204 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { NativeModules, NativeEventEmitter, Platform, Dimensions, PixelRatio, View } from 'react-native';
+const { RNStrata } = NativeModules;
+if (!RNStrata && Platform.OS === 'ios') {
+    console.warn('RNStrata: Native module not found. Check your native installation.');
+}
+const eventEmitter = RNStrata ? new NativeEventEmitter(RNStrata) : null;
+/**
+ * Hook to get and track device information
+ */
+export function useDevice() {
+    const [deviceProfile, setDeviceProfile] = useState(() => {
+        const { width, height } = Dimensions.get('window');
+        return {
+            deviceType: 'mobile',
+            platform: Platform.OS,
+            inputMode: 'touch',
+            orientation: height >= width ? 'portrait' : 'landscape',
+            hasTouch: true,
+            hasGamepad: false,
+            screenWidth: width,
+            screenHeight: height,
+            pixelRatio: PixelRatio.get(),
+            safeAreaInsets: { top: 0, right: 0, bottom: 0, left: 0 },
+            performanceMode: 'high',
+        };
+    });
+    useEffect(() => {
+        const updateDeviceInfo = async () => {
+            if (Platform.OS === 'ios' && RNStrata) {
+                try {
+                    const details = await RNStrata.getDeviceDetails();
+                    setDeviceProfile({
+                        ...details,
+                        performanceMode: 'high', // Default for now as not in RNStrata yet
+                    });
+                }
+                catch (e) {
+                    console.error('Failed to get native device details', e);
+                }
+            }
+            else {
+                const { width, height } = Dimensions.get('window');
+                setDeviceProfile(prev => ({
+                    ...prev,
+                    screenWidth: width,
+                    screenHeight: height,
+                    orientation: height >= width ? 'portrait' : 'landscape',
+                }));
+            }
+        };
+        updateDeviceInfo();
+        const subscription = Dimensions.addEventListener('change', updateDeviceInfo);
+        return () => {
+            if (subscription?.remove) {
+                subscription.remove();
+            }
+        };
+    }, []);
+    return deviceProfile;
+}
+/**
+ * Hook to handle input state
+ */
+export function useInput() {
+    const [input, setInput] = useState({
+        timestamp: Date.now(),
+        leftStick: { x: 0, y: 0 },
+        rightStick: { x: 0, y: 0 },
+        buttons: {},
+        triggers: { left: 0, right: 0 },
+        touches: [],
+    });
+    useEffect(() => {
+        let interval;
+        if (Platform.OS === 'ios' && RNStrata) {
+            interval = setInterval(async () => {
+                try {
+                    const snapshot = await RNStrata.getGamepadSnapshot();
+                    if (snapshot) {
+                        setInput(prev => ({
+                            ...snapshot,
+                            touches: prev.touches, // Preserve touches from provider
+                        }));
+                    }
+                }
+                catch (_e) {
+                    // Ignore gamepad errors in poll
+                }
+            }, 16); // ~60fps
+        }
+        return () => {
+            if (interval)
+                clearInterval(interval);
+        };
+    }, []);
+    return input;
+}
+/**
+ * A component that captures touch gestures and provides them to the game
+ */
+export const StrataInputProvider = ({ children, onInput }) => {
+    const touches = useRef(new Map());
+    const updateTouches = (event) => {
+        const changedTouches = event.nativeEvent.changedTouches;
+        const timestamp = event.nativeEvent.timestamp;
+        changedTouches.forEach(touch => {
+            touches.current.set(touch.identifier, {
+                identifier: touch.identifier,
+                pageX: touch.pageX,
+                pageY: touch.pageY,
+                locationX: touch.locationX,
+                locationY: touch.locationY,
+                timestamp,
+            });
+        });
+        const snapshot = {
+            timestamp,
+            leftStick: { x: 0, y: 0 },
+            rightStick: { x: 0, y: 0 },
+            buttons: {},
+            triggers: { left: 0, right: 0 },
+            touches: Array.from(touches.current.values()),
+        };
+        onInput?.(snapshot);
+    };
+    const removeTouches = (event) => {
+        const changedTouches = event.nativeEvent.changedTouches;
+        changedTouches.forEach(touch => {
+            touches.current.delete(touch.identifier);
+        });
+        const snapshot = {
+            timestamp: event.nativeEvent.timestamp,
+            leftStick: { x: 0, y: 0 },
+            rightStick: { x: 0, y: 0 },
+            buttons: {},
+            triggers: { left: 0, right: 0 },
+            touches: Array.from(touches.current.values()),
+        };
+        onInput?.(snapshot);
+    };
+    return (<View style={{ flex: 1 }} onStartShouldSetResponder={() => true} onMoveShouldSetResponder={() => true} onResponderGrant={updateTouches} onResponderMove={updateTouches} onResponderRelease={removeTouches} onResponderTerminate={removeTouches}>
+      {children}
+    </View>);
+};
+/**
+ * Hook for haptic feedback
+ */
+export function useHaptics() {
+    const trigger = useCallback(async (options) => {
+        if (Platform.OS === 'web') {
+            if ('vibrate' in navigator) {
+                navigator.vibrate(options.duration || 50);
+            }
+            return;
+        }
+        if (Platform.OS === 'ios' && RNStrata) {
+            RNStrata.triggerHaptic(options.type || 'impact', options);
+        }
+    }, []);
+    return { trigger };
+}
+/**
+ * Set screen orientation
+ */
+export async function setOrientation(_orientation) {
+    // Not implemented in RNStrata yet, but keeping the API
+    console.warn('setOrientation is not yet implemented in RNStrata');
+}
+/**
+ * Hook for control hints based on device and input
+ */
+export function useControlHints() {
+    const { inputMode, hasGamepad } = useDevice();
+    if (hasGamepad || inputMode === 'gamepad') {
+        return {
+            movement: 'Left Stick',
+            action: 'Button A / X',
+            camera: 'Right Stick'
+        };
+    }
+    if (inputMode === 'touch') {
+        return {
+            movement: 'Virtual Joystick',
+            action: 'Tap Screen',
+            camera: 'Drag'
+        };
+    }
+    return {
+        movement: 'WASD / Left Stick',
+        action: 'Space / Button A',
+        camera: 'Mouse / Right Stick'
+    };
+}
+/**
+ * Subscribe to gamepad connection events
+ */
+export function onGamepadUpdate(callback) {
+    if (eventEmitter) {
+        return eventEmitter.addListener('onGamepadUpdate', callback);
+    }
+    return null;
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"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"}

package/dist/tests/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/tests/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/tests/index.test.tsx"],"names":[],"mappings":""}

package/dist/tests/index.test.js

@@ -0,0 +1,49 @@
+import { renderHook } from '@testing-library/react-hooks/native';
+import { useDevice } from '../index';
+import { NativeModules } from 'react-native';
+jest.mock('react-native', () => ({
+    NativeModules: {
+        RNStrata: {
+            getDeviceDetails: jest.fn(),
+            getGamepadSnapshot: jest.fn(),
+            triggerHaptic: jest.fn(),
+        },
+    },
+    NativeEventEmitter: jest.fn(() => ({
+        addListener: jest.fn(),
+        removeListeners: jest.fn(),
+    })),
+    Platform: {
+        OS: 'ios',
+        select: jest.fn(obj => obj.ios),
+    },
+    Dimensions: {
+        get: jest.fn(() => ({ width: 390, height: 844 })),
+        addEventListener: jest.fn(() => ({ remove: jest.fn() })),
+    },
+    PixelRatio: {
+        get: jest.fn(() => 3),
+    },
+}));
+describe('useDevice', () => {
+    it('should return initial device profile', () => {
+        const mockDetails = {
+            deviceType: 'mobile',
+            platform: 'ios',
+            inputMode: 'touch',
+            orientation: 'portrait',
+            hasTouch: true,
+            hasGamepad: false,
+            screenWidth: 390,
+            screenHeight: 844,
+            pixelRatio: 3,
+            safeAreaInsets: { top: 47, right: 0, bottom: 34, left: 0 }
+        };
+        NativeModules.RNStrata.getDeviceDetails.mockResolvedValue(mockDetails);
+        const { result } = renderHook(() => useDevice());
+        // Initial state
+        expect(result.current.platform).toBe('ios');
+        expect(result.current.hasTouch).toBe(true);
+    });
+});
+//# sourceMappingURL=index.test.js.map

package/dist/tests/index.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.js","sourceRoot":"","sources":["../../src/tests/index.test.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC;IAC/B,aAAa,EAAE;QACb,QAAQ,EAAE;YACR,gBAAgB,EAAE,IAAI,CAAC,EAAE,EAAE;YAC3B,kBAAkB,EAAE,IAAI,CAAC,EAAE,EAAE;YAC7B,aAAa,EAAE,IAAI,CAAC,EAAE,EAAE;SACzB;KACF;IACD,kBAAkB,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;QACjC,WAAW,EAAE,IAAI,CAAC,EAAE,EAAE;QACtB,eAAe,EAAE,IAAI,CAAC,EAAE,EAAE;KAC3B,CAAC,CAAC;IACH,QAAQ,EAAE;QACR,EAAE,EAAE,KAAK;QACT,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC;KAChC;IACD,UAAU,EAAE;QACV,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;QACjD,gBAAgB,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;KACzD;IACD,UAAU,EAAE;QACV,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;KACtB;CACF,CAAC,CAAC,CAAC;AAEJ,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;IACzB,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAC9C,MAAM,WAAW,GAAG;YAClB,UAAU,EAAE,QAAQ;YACpB,QAAQ,EAAE,KAAK;YACf,SAAS,EAAE,OAAO;YAClB,WAAW,EAAE,UAAU;YACvB,QAAQ,EAAE,IAAI;YACd,UAAU,EAAE,KAAK;YACjB,WAAW,EAAE,GAAG;YAChB,YAAY,EAAE,GAAG;YACjB,UAAU,EAAE,CAAC;YACb,cAAc,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE;SAC3D,CAAC;QAED,aAAa,CAAC,QAAQ,CAAC,gBAA8B,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;QAEtF,MAAM,EAAE,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,CAAC,CAAC;QAEjD,gBAAgB;QAChB,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5C,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/ios/RNStrata/RNStrata.m

@@ -0,0 +1,15 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(RNStrata, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(getDeviceDetails:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(triggerHaptic:(NSString *)type
+                  options:(NSDictionary *)options)
+
+RCT_EXTERN_METHOD(getGamepadSnapshot:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/RNStrata/RNStrata.swift

@@ -0,0 +1,239 @@
+import Foundation
+import UIKit
+import GameController
+import React
+
+@objc(RNStrata)
+class RNStrata: RCTEventEmitter {
+  
+  private var hasListeners = false
+  
+  override func supportedEvents() -> [String]! {
+    return ["onGamepadUpdate"]
+  }
+  
+  override func startObserving() {
+    hasListeners = true
+    setupGamepadObservers()
+  }
+  
+  override func stopObserving() {
+    hasListeners = false
+    NotificationCenter.default.removeObserver(self)
+  }
+  
+  @objc override static func requiresMainQueueSetup() -> Bool {
+    return true
+  }
+
+  // MARK: - Device Detection
+  
+  @objc(getDeviceDetails:rejecter:)
+  func getDeviceDetails(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      do {
+        let device = UIDevice.current
+        let screen = UIScreen.main
+        let bounds = screen.bounds
+        
+        var deviceType = "mobile"
+        if device.userInterfaceIdiom == .pad {
+          deviceType = "tablet"
+        } else if #available(iOS 14.0, *), device.userInterfaceIdiom == .mac {
+          deviceType = "desktop"
+        }
+        #if targetEnvironment(macCatalyst)
+        deviceType = "desktop"
+        #endif
+        
+        let orientation: String
+        if let windowScene = self.getKeyWindow()?.windowScene {
+          switch windowScene.interfaceOrientation {
+          case .landscapeLeft, .landscapeRight:
+            orientation = "landscape"
+          default:
+            orientation = "portrait"
+          }
+        } else {
+          orientation = "portrait"
+        }
+        
+        let window = self.getKeyWindow()
+        let safeArea = window?.safeAreaInsets ?? .zero
+        
+        let hasGamepad = GCController.controllers().count > 0
+        
+        let details: [String: Any] = [
+          "deviceType": deviceType,
+          "platform": "ios",
+          "inputMode": hasGamepad ? "gamepad" : "touch",
+          "orientation": orientation,
+          "hasTouch": true,
+          "hasGamepad": hasGamepad,
+          "screenWidth": bounds.width,
+          "screenHeight": bounds.height,
+          "pixelRatio": screen.scale,
+          "safeAreaInsets": [
+            "top": safeArea.top,
+            "right": safeArea.right,
+            "bottom": safeArea.bottom,
+            "left": safeArea.left
+          ]
+        ]
+        
+        resolve(details)
+      } catch {
+        reject("DEVICE_ERROR", "Failed to get device details: \(error.localizedDescription)", error)
+      }
+    }
+  }
+
+  private func getKeyWindow() -> UIWindow? {
+    if #available(iOS 13.0, *) {
+      return UIApplication.shared.connectedScenes
+        .filter({$0.activationState == .foregroundActive})
+        .map({$0 as? UIWindowScene})
+        .compactMap({$0})
+        .first?.windows
+        .filter({$0.isKeyWindow}).first
+    } else {
+      return UIApplication.shared.keyWindow
+    }
+  }
+
+  // MARK: - Haptic Feedback
+  
+  @objc(triggerHaptic:options:)
+  func triggerHaptic(type: String, options: [String: Any]) {
+    DispatchQueue.main.async {
+      switch type {
+      case "impact":
+        let styleStr = options["intensity"] as? String ?? "medium"
+        var style: UIImpactFeedbackGenerator.FeedbackStyle = .medium
+        
+        switch styleStr {
+        case "light": style = .light
+        case "medium": style = .medium
+        case "heavy": style = .heavy
+        default: style = .medium
+        }
+        
+        let generator = UIImpactFeedbackGenerator(style: style)
+        generator.prepare()
+        generator.impactOccurred()
+        
+      case "notification":
+        let styleStr = options["intensity"] as? String ?? "success"
+        var style: UINotificationFeedbackGenerator.FeedbackType = .success
+        
+        switch styleStr {
+        case "success": style = .success
+        case "warning": style = .warning
+        case "error": style = .error
+        default: style = .success
+        }
+        
+        let generator = UINotificationFeedbackGenerator()
+        generator.prepare()
+        generator.notificationOccurred(style)
+        
+      case "selection":
+        let generator = UISelectionFeedbackGenerator()
+        generator.prepare()
+        generator.selectionChanged()
+        
+      default:
+        break
+      }
+    }
+  }
+
+  // MARK: - Gamepad Support
+  
+  private func setupGamepadObservers() {
+    // Remove existing observers first to prevent duplicates
+    NotificationCenter.default.removeObserver(self, name: .GCControllerDidConnect, object: nil)
+    NotificationCenter.default.removeObserver(self, name: .GCControllerDidDisconnect, object: nil)
+    
+    NotificationCenter.default.addObserver(self, selector: #selector(gamepadDidConnect), name: .GCControllerDidConnect, object: nil)
+    NotificationCenter.default.addObserver(self, selector: #selector(gamepadDidDisconnect), name: .GCControllerDidDisconnect, object: nil)
+  }
+  
+  @objc private func gamepadDidConnect(notification: Notification) {
+    // Handle gamepad connection
+    if hasListeners {
+      sendEvent(withName: "onGamepadUpdate", body: ["connected": true])
+    }
+  }
+  
+  @objc private func gamepadDidDisconnect(notification: Notification) {
+    // Handle gamepad disconnection
+    if hasListeners {
+      sendEvent(withName: "onGamepadUpdate", body: ["connected": false])
+    }
+  }
+
+  @objc(getGamepadSnapshot:rejecter:)
+  func getGamepadSnapshot(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    do {
+      let controllers = GCController.controllers()
+      guard let controller = controllers.first else {
+        resolve(nil)
+        return
+      }
+      
+      var snapshot: [String: Any] = [:]
+      
+      if let gamepad = controller.extendedGamepad {
+        snapshot["leftStick"] = ["x": gamepad.leftThumbstick.xAxis.value, "y": gamepad.leftThumbstick.yAxis.value]
+        snapshot["rightStick"] = ["x": gamepad.rightThumbstick.xAxis.value, "y": gamepad.rightThumbstick.yAxis.value]
+        
+        var buttons: [String: Bool] = [
+          "a": gamepad.buttonA.isPressed,
+          "b": gamepad.buttonB.isPressed,
+          "x": gamepad.buttonX.isPressed,
+          "y": gamepad.buttonY.isPressed,
+          "leftShoulder": gamepad.leftShoulder.isPressed,
+          "rightShoulder": gamepad.rightShoulder.isPressed,
+          "leftTrigger": gamepad.leftTrigger.isPressed,
+          "rightTrigger": gamepad.rightTrigger.isPressed,
+          "dpadUp": gamepad.dpad.up.isPressed,
+          "dpadDown": gamepad.dpad.down.isPressed,
+          "dpadLeft": gamepad.dpad.left.isPressed,
+          "dpadRight": gamepad.dpad.right.isPressed
+        ]
+        
+        if #available(iOS 12.1, *) {
+          buttons["leftStickButton"] = gamepad.leftThumbstickButton?.isPressed ?? false
+          buttons["rightStickButton"] = gamepad.rightThumbstickButton?.isPressed ?? false
+        }
+        
+        if #available(iOS 13.0, *) {
+          buttons["menu"] = gamepad.buttonMenu.isPressed
+          buttons["options"] = gamepad.buttonOptions?.isPressed ?? false
+        }
+        
+        if #available(iOS 14.0, *) {
+          buttons["home"] = gamepad.buttonHome?.isPressed ?? false
+        }
+        
+        snapshot["buttons"] = buttons
+        snapshot["triggers"] = [
+          "left": gamepad.leftTrigger.value,
+          "right": gamepad.rightTrigger.value
+        ]
+      } else {
+        // Provide default values for simpler controllers to match InputSnapshot interface
+        snapshot["leftStick"] = ["x": 0, "y": 0]
+        snapshot["rightStick"] = ["x": 0, "y": 0]
+        snapshot["buttons"] = [:]
+        snapshot["triggers"] = ["left": 0, "right": 0]
+      }
+      
+      snapshot["timestamp"] = Date().timeIntervalSince1970 * 1000
+      resolve(snapshot)
+    } catch {
+      reject("GAMEPAD_ERROR", "Failed to get gamepad snapshot: \(error.localizedDescription)", error)
+    }
+  }
+}

package/ios/jbcom-strata-react-native-plugin.podspec

@@ -0,0 +1,19 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "RNStrata"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "12.0" }
+  s.source       = { :git => "https://github.com/jbcom/nodejs-strata-react-native-plugin.git", :tag => "#{s.version}" }
+
+  s.source_files = "RNStrata/**/*.{h,m,mm,swift}"
+
+  s.dependency "React-Core"
+end

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@strata-game-library/react-native-plugin",
+  "version": "1.0.0",
+  "description": "React Native plugin for Strata 3D - cross-platform input, device detection, and haptics for mobile games",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "android",
+    "ios",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "lint": "biome lint src/",
+    "lint:fix": "biome lint --write src/",
+    "format": "biome format --write src/"
+  },
+  "keywords": [
+    "react-native",
+    "strata",
+    "input",
+    "gamepad",
+    "touch",
+    "haptics",
+    "device-detection",
+    "cross-platform",
+    "mobile",
+    "ios",
+    "android"
+  ],
+  "author": "Jon Bogaty <jon@jonbogaty.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/strata-game-library/react-native-plugin"
+  },
+  "homepage": "https://strata.game/react-native-plugin",
+  "bugs": {
+    "url": "https://github.com/strata-game-library/react-native-plugin/issues"
+  },
+  "peerDependencies": {
+    "@strata-game-library/core": ">=1.4.0",
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.0",
+    "@react-native/babel-preset": "^0.83.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@testing-library/react-hooks": "^8.0.1",
+    "@testing-library/react-native": "^13.3.3",
+    "@types/jest": "^30.0.0",
+    "@types/react": "^19.0.0",
+    "babel-jest": "^30.2.0",
+    "jest": "^30.2.0",
+    "react": "^19.2.3",
+    "react-native": "^0.83.1",
+    "react-test-renderer": "^19.2.3",
+    "rimraf": "^6.1.0",
+    "semantic-release": "^25.0.2",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}