@teardown/dev-client 2.0.44

package/android/build.gradle.kts

@@ -0,0 +1,34 @@
+plugins {
+    id("com.android.library")
+    id("kotlin-android")
+}
+
+android {
+    namespace = "com.teardown.devclient"
+    compileSdk = 34
+
+    defaultConfig {
+        minSdk = 23
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+dependencies {
+    implementation("com.facebook.react:react-android")
+    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.9.22")
+}

package/android/react-native.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        packageImportPath: 'import com.teardown.devclient.TeardownDevClientPackage;',
+        packageInstance: 'new TeardownDevClientPackage()',
+      },
+    },
+  },
+};

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.teardown.devclient">
+
+    <!-- No permissions required for dev client functionality -->
+
+</manifest>

package/android/src/main/java/com/teardown/devclient/DevSettingsModule.kt

@@ -0,0 +1,130 @@
+package com.teardown.devclient
+
+import com.facebook.react.bridge.*
+import com.facebook.react.devsupport.DevInternalSettings
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+/**
+ * Native module for controlling React Native dev settings
+ */
+class DevSettingsModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "TeardownDevSettings"
+
+    /**
+     * Reload the JavaScript bundle
+     */
+    @ReactMethod
+    fun reload() {
+        reactApplicationContext.runOnUiQueueThread {
+            try {
+                getDevSupportManager()?.handleReloadJS()
+            } catch (e: Exception) {
+                // Ignore errors if dev support is not available
+            }
+        }
+    }
+
+    /**
+     * Open the debugger
+     */
+    @ReactMethod
+    fun openDebugger() {
+        reactApplicationContext.runOnUiQueueThread {
+            try {
+                getDevSupportManager()?.showDevOptionsDialog()
+            } catch (e: Exception) {
+                // Ignore errors if dev support is not available
+            }
+        }
+    }
+
+    /**
+     * Toggle element inspector overlay
+     */
+    @ReactMethod
+    fun toggleElementInspector() {
+        reactApplicationContext.runOnUiQueueThread {
+            try {
+                getDevSupportManager()?.toggleElementInspector()
+            } catch (e: Exception) {
+                // Ignore errors if dev support is not available
+            }
+        }
+    }
+
+    /**
+     * Set hot loading enabled state
+     */
+    @ReactMethod
+    fun setHotLoadingEnabled(enabled: Boolean) {
+        try {
+            getDevSettings()?.isHotModuleReplacementEnabled = enabled
+        } catch (e: Exception) {
+            // Ignore errors
+        }
+    }
+
+    /**
+     * Set fast refresh enabled state
+     */
+    @ReactMethod
+    fun setFastRefreshEnabled(enabled: Boolean) {
+        // Fast refresh uses the same setting as hot loading
+        setHotLoadingEnabled(enabled)
+    }
+
+    /**
+     * Get current dev settings
+     */
+    @ReactMethod
+    fun getDevSettings(promise: Promise) {
+        try {
+            val devSettings = getDevSettings()
+            val result = Arguments.createMap().apply {
+                putBoolean("isDebuggingRemotely", devSettings?.isRemoteJSDebugEnabled ?: false)
+                putBoolean("isElementInspectorShown", false) // Not easily accessible on Android
+                putBoolean("isHotLoadingEnabled", devSettings?.isHotModuleReplacementEnabled ?: false)
+                putBoolean("isFastRefreshEnabled", devSettings?.isHotModuleReplacementEnabled ?: false)
+                putBoolean("isPerfMonitorShown", devSettings?.isFpsDebugEnabled ?: false)
+            }
+            promise.resolve(result)
+        } catch (e: Exception) {
+            // Return defaults if dev settings not available
+            val result = Arguments.createMap().apply {
+                putBoolean("isDebuggingRemotely", false)
+                putBoolean("isElementInspectorShown", false)
+                putBoolean("isHotLoadingEnabled", false)
+                putBoolean("isFastRefreshEnabled", false)
+                putBoolean("isPerfMonitorShown", false)
+            }
+            promise.resolve(result)
+        }
+    }
+
+    /**
+     * Open native dev menu
+     */
+    @ReactMethod
+    fun openDevMenu() {
+        reactApplicationContext.runOnUiQueueThread {
+            try {
+                getDevSupportManager()?.showDevOptionsDialog()
+            } catch (e: Exception) {
+                // Ignore errors if dev support is not available
+            }
+        }
+    }
+
+    private fun getDevSupportManager() =
+        reactApplicationContext.currentActivity?.let { activity ->
+            (activity.application as? com.facebook.react.ReactApplication)
+                ?.reactNativeHost
+                ?.reactInstanceManager
+                ?.devSupportManager
+        }
+
+    private fun getDevSettings(): DevInternalSettings? =
+        getDevSupportManager()?.devSettings as? DevInternalSettings
+}

package/android/src/main/java/com/teardown/devclient/ShakeDetectorModule.kt

@@ -0,0 +1,118 @@
+package com.teardown.devclient
+
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.content.Context
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import kotlin.math.sqrt
+
+/**
+ * Native module for detecting shake gestures
+ */
+class ShakeDetectorModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), SensorEventListener {
+
+    private var sensorManager: SensorManager? = null
+    private var accelerometer: Sensor? = null
+    private var isListening = false
+
+    // Shake detection parameters
+    private var lastShakeTime: Long = 0
+    private var lastX = 0f
+    private var lastY = 0f
+    private var lastZ = 0f
+    private var lastUpdate: Long = 0
+
+    companion object {
+        private const val SHAKE_THRESHOLD = 800
+        private const val SHAKE_SLOP_TIME_MS = 500
+        private const val SHAKE_COUNT_RESET_TIME_MS = 3000
+    }
+
+    override fun getName(): String = "TeardownShakeDetector"
+
+    override fun initialize() {
+        super.initialize()
+        sensorManager = reactContext.getSystemService(Context.SENSOR_SERVICE) as? SensorManager
+        accelerometer = sensorManager?.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+    }
+
+    /**
+     * Start listening for shake gestures
+     */
+    @ReactMethod
+    fun startListening() {
+        if (isListening) return
+
+        accelerometer?.let { sensor ->
+            sensorManager?.registerListener(
+                this,
+                sensor,
+                SensorManager.SENSOR_DELAY_UI
+            )
+            isListening = true
+        }
+    }
+
+    /**
+     * Stop listening for shake gestures
+     */
+    @ReactMethod
+    fun stopListening() {
+        if (!isListening) return
+
+        sensorManager?.unregisterListener(this)
+        isListening = false
+    }
+
+    override fun onSensorChanged(event: SensorEvent?) {
+        event ?: return
+
+        val currentTime = System.currentTimeMillis()
+
+        if ((currentTime - lastUpdate) > 100) {
+            val diffTime = currentTime - lastUpdate
+            lastUpdate = currentTime
+
+            val x = event.values[0]
+            val y = event.values[1]
+            val z = event.values[2]
+
+            val speed = sqrt(
+                ((x - lastX) * (x - lastX) +
+                    (y - lastY) * (y - lastY) +
+                    (z - lastZ) * (z - lastZ)).toDouble()
+            ) / diffTime * 10000
+
+            if (speed > SHAKE_THRESHOLD) {
+                // Debounce shake events
+                if (currentTime - lastShakeTime > SHAKE_SLOP_TIME_MS) {
+                    lastShakeTime = currentTime
+                    emitShakeEvent()
+                }
+            }
+
+            lastX = x
+            lastY = y
+            lastZ = z
+        }
+    }
+
+    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
+        // Not needed
+    }
+
+    private fun emitShakeEvent() {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("TeardownShakeEvent", null)
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        stopListening()
+    }
+}

package/android/src/main/java/com/teardown/devclient/TeardownDevClientPackage.kt

@@ -0,0 +1,23 @@
+package com.teardown.devclient
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native package for Teardown Dev Client
+ */
+class TeardownDevClientPackage : ReactPackage {
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(
+            DevSettingsModule(reactContext),
+            ShakeDetectorModule(reactContext)
+        )
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/ios/TeardownDevClient/DevSettingsModule.swift

@@ -0,0 +1,135 @@
+//
+//  DevSettingsModule.swift
+//  TeardownDevClient
+//
+//  Native module for controlling React Native dev settings
+//
+
+import Foundation
+import React
+
+@objc(TeardownDevSettings)
+class DevSettingsModule: NSObject {
+
+    private var bridge: RCTBridge?
+
+    @objc
+    static func moduleName() -> String! {
+        return "TeardownDevSettings"
+    }
+
+    @objc
+    func setBridge(_ bridge: RCTBridge) {
+        self.bridge = bridge
+    }
+
+    /// Reload the JavaScript bundle
+    @objc
+    func reload() {
+        DispatchQueue.main.async {
+            RCTTriggerReloadCommandListeners("TeardownDevClient")
+        }
+    }
+
+    /// Open the debugger
+    @objc
+    func openDebugger() {
+        DispatchQueue.main.async {
+            #if DEBUG
+            // In debug mode, this would open the debugger
+            // The actual implementation depends on the debugger being used
+            NotificationCenter.default.post(
+                name: NSNotification.Name("RCTShowDevMenuNotification"),
+                object: nil
+            )
+            #endif
+        }
+    }
+
+    /// Toggle element inspector overlay
+    @objc
+    func toggleElementInspector() {
+        DispatchQueue.main.async {
+            #if DEBUG
+            if let devSettings = RCTDevSettings.sharedInstance() {
+                devSettings.toggleElementInspector()
+            }
+            #endif
+        }
+    }
+
+    /// Set hot loading enabled state
+    @objc(setHotLoadingEnabled:)
+    func setHotLoadingEnabled(_ enabled: Bool) {
+        DispatchQueue.main.async {
+            #if DEBUG
+            if let devSettings = RCTDevSettings.sharedInstance() {
+                devSettings.isHotLoadingEnabled = enabled
+            }
+            #endif
+        }
+    }
+
+    /// Set fast refresh enabled state
+    @objc(setFastRefreshEnabled:)
+    func setFastRefreshEnabled(_ enabled: Bool) {
+        // Fast refresh uses the same setting as hot loading in RN
+        setHotLoadingEnabled(enabled)
+    }
+
+    /// Get current dev settings
+    @objc(getDevSettings:rejecter:)
+    func getDevSettings(
+        _ resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        DispatchQueue.main.async {
+            #if DEBUG
+            guard let devSettings = RCTDevSettings.sharedInstance() else {
+                let settings: [String: Any] = [
+                    "isDebuggingRemotely": false,
+                    "isElementInspectorShown": false,
+                    "isHotLoadingEnabled": true,
+                    "isFastRefreshEnabled": true,
+                    "isPerfMonitorShown": false
+                ]
+                resolve(settings)
+                return
+            }
+
+            let settings: [String: Any] = [
+                "isDebuggingRemotely": devSettings.isDebuggingRemotely,
+                "isElementInspectorShown": devSettings.isElementInspectorShown,
+                "isHotLoadingEnabled": devSettings.isHotLoadingEnabled,
+                "isFastRefreshEnabled": devSettings.isHotLoadingEnabled,
+                "isPerfMonitorShown": devSettings.isPerfMonitorShown
+            ]
+
+            resolve(settings)
+            #else
+            // In release mode, return defaults
+            let settings: [String: Any] = [
+                "isDebuggingRemotely": false,
+                "isElementInspectorShown": false,
+                "isHotLoadingEnabled": false,
+                "isFastRefreshEnabled": false,
+                "isPerfMonitorShown": false
+            ]
+            resolve(settings)
+            #endif
+        }
+    }
+
+    /// Open native dev menu
+    @objc
+    func openDevMenu() {
+        DispatchQueue.main.async {
+            #if DEBUG
+            NotificationCenter.default.post(
+                name: NSNotification.Name("RCTShowDevMenuNotification"),
+                object: nil
+            )
+            #endif
+        }
+    }
+}

package/ios/TeardownDevClient/ShakeDetector.swift

@@ -0,0 +1,102 @@
+//
+//  ShakeDetector.swift
+//  TeardownDevClient
+//
+//  Native module for detecting shake gestures
+//
+
+import Foundation
+import UIKit
+import React
+
+@objc(TeardownShakeDetector)
+class ShakeDetector: RCTEventEmitter {
+
+    private var isListening = false
+    private var motionManager: CMMotionManager?
+
+    override init() {
+        super.init()
+        setupShakeNotification()
+    }
+
+    @objc
+    override static func moduleName() -> String! {
+        return "TeardownShakeDetector"
+    }
+
+    @objc
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    @objc
+    override func supportedEvents() -> [String]! {
+        return ["TeardownShakeEvent"]
+    }
+
+    private func setupShakeNotification() {
+        // Listen for shake motion events from the app delegate
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleShakeMotion),
+            name: NSNotification.Name("TeardownShakeMotion"),
+            object: nil
+        )
+    }
+
+    @objc
+    private func handleShakeMotion() {
+        guard isListening else { return }
+
+        DispatchQueue.main.async {
+            self.sendEvent(withName: "TeardownShakeEvent", body: nil)
+        }
+    }
+
+    /// Start listening for shake gestures
+    @objc
+    func startListening() {
+        isListening = true
+    }
+
+    /// Stop listening for shake gestures
+    @objc
+    func stopListening() {
+        isListening = false
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+}
+
+// MARK: - UIWindow Extension for Shake Detection
+
+// This extension should be added to the app's AppDelegate to enable shake detection
+// Example usage in AppDelegate:
+//
+// override func motionEnded(_ motion: UIEvent.EventSubtype, with event: UIEvent?) {
+//     if motion == .motionShake {
+//         NotificationCenter.default.post(name: NSNotification.Name("TeardownShakeMotion"), object: nil)
+//     }
+// }
+
+import CoreMotion
+
+private var associatedMotionManagerKey: UInt8 = 0
+
+extension UIWindow {
+
+    /// Override to detect shake motion
+    open override func motionEnded(_ motion: UIEvent.EventSubtype, with event: UIEvent?) {
+        super.motionEnded(motion, with: event)
+
+        if motion == .motionShake {
+            NotificationCenter.default.post(
+                name: NSNotification.Name("TeardownShakeMotion"),
+                object: nil
+            )
+        }
+    }
+}

package/ios/TeardownDevClient/TeardownDevClient.h

@@ -0,0 +1,14 @@
+//
+//  TeardownDevClient.h
+//  TeardownDevClient
+//
+//  Umbrella header for TeardownDevClient native module
+//
+
+#import <Foundation/Foundation.h>
+
+//! Project version number for TeardownDevClient.
+FOUNDATION_EXPORT double TeardownDevClientVersionNumber;
+
+//! Project version string for TeardownDevClient.
+FOUNDATION_EXPORT const unsigned char TeardownDevClientVersionString[];

package/ios/TeardownDevClient/TeardownDevClient.mm

@@ -0,0 +1,42 @@
+//
+//  TeardownDevClient.mm
+//  TeardownDevClient
+//
+//  Bridge file for React Native integration
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+// TeardownDevSettings module
+@interface RCT_EXTERN_MODULE(TeardownDevSettings, NSObject)
+
+RCT_EXTERN_METHOD(reload)
+RCT_EXTERN_METHOD(openDebugger)
+RCT_EXTERN_METHOD(toggleElementInspector)
+RCT_EXTERN_METHOD(setHotLoadingEnabled:(BOOL)enabled)
+RCT_EXTERN_METHOD(setFastRefreshEnabled:(BOOL)enabled)
+RCT_EXTERN_METHOD(getDevSettings:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(openDevMenu)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+@end
+
+// TeardownShakeDetector module
+@interface RCT_EXTERN_MODULE(TeardownShakeDetector, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(startListening)
+RCT_EXTERN_METHOD(stopListening)
+RCT_EXTERN_METHOD(supportedEvents)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+@end

package/ios/TeardownDevClient.podspec

@@ -0,0 +1,23 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = "TeardownDevClient"
+  s.version      = package['version']
+  s.summary      = "Development client for Teardown React Native apps"
+  s.description  = <<-DESC
+    Provides development client functionality including dev menu,
+    splash screen control, and shake detection for Teardown apps.
+  DESC
+  s.homepage     = "https://github.com/teardown-dev/teardown"
+  s.license      = package['license']
+  s.authors      = { "Teardown" => "dev@teardown.dev" }
+  s.platforms    = { :ios => "13.4" }
+  s.source       = { :git => "https://github.com/teardown-dev/teardown.git", :tag => "v#{s.version}" }
+
+  s.source_files = "TeardownDevClient/**/*.{h,m,mm,swift}"
+  s.swift_version = "5.0"
+
+  s.dependency "React-Core"
+end

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "@teardown/dev-client",
+	"version": "2.0.44",
+	"private": false,
+	"type": "module",
+	"publishConfig": {
+		"access": "public"
+	},
+	"files": [
+		"src/**/*",
+		"ios/**/*",
+		"android/**/*"
+	],
+	"main": "./src/index.ts",
+	"module": "./src/index.ts",
+	"types": "./src/index.ts",
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"types": "./src/index.ts",
+			"import": "./src/index.ts",
+			"default": "./src/index.ts"
+		}
+	},
+	"scripts": {
+		"typecheck": "tsc --noEmit --project ./tsconfig.json",
+		"lint": "bun x biome lint --write ./src",
+		"fmt": "bun x biome format --write ./src",
+		"check": "bun x biome check ./src",
+		"test": "bun test"
+	},
+	"dependencies": {
+		"eventemitter3": "^5.0.1"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.3.11",
+		"@teardown/tsconfig": "2.0.44",
+		"@types/bun": "1.3.5",
+		"@types/react": "~19.1.0",
+		"react": "19.1.0",
+		"react-native": "0.81.5",
+		"typescript": "5.9.3"
+	},
+	"peerDependencies": {
+		"react": ">=18",
+		"react-native": ">=0.73"
+	},
+	"peerDependenciesMeta": {
+		"react": {
+			"optional": false
+		},
+		"react-native": {
+			"optional": false
+		}
+	}
+}