catalyst-core 0.0.3-canary.7 → 0.0.3-canary.8

package/changelog.md

@@ -1,44 +1,58 @@
 # Changelog
 
+## [0.0.3-canary.8] - 2025-01-06
+
+-   **App icon configuration**
+-   **Splash screen integration**
+-   **Url Whitelisting**
 
 ## [0.0.3-canary.7] - 2025-01-06
 
 ### 🚀 Features
-- **Native API Integration**: Enhanced native module integration for better performance
-- **Automated IP Resolution**: Intelligent network detection eliminates manual IP configuration
-- **Universal Build System**: Streamlined one-command builds for both Android and iOS platforms
-- **Enhanced CLI Interface**: Improved command-line tools for better developer experience
 
-### 🐛 Bug Fixes  
-- Fixed IP address detection issues on development environments
-- Resolved build configuration conflicts between platforms
-- Improved error handling and recovery mechanisms
+-   **Native API Integration**: Enhanced native module integration for better performance
+-   **Automated IP Resolution**: Intelligent network detection eliminates manual IP configuration
+-   **Universal Build System**: Streamlined one-command builds for both Android and iOS platforms
+-   **Enhanced CLI Interface**: Improved command-line tools for better developer experience
+
+### 🐛 Bug Fixes
+
+-   Fixed IP address detection issues on development environments
+-   Resolved build configuration conflicts between platforms
+-   Improved error handling and recovery mechanisms
 
 ### 🔧 Improvements
-- **Performance**: Optimized native module loading and execution
-- **Developer Experience**: Enhanced CLI with better error messages and debugging info  
-- **Configuration**: Dynamic config updates without requiring restarts
-- **Build Process**: Faster and more reliable build pipeline
+
+-   **Performance**: Optimized native module loading and execution
+-   **Developer Experience**: Enhanced CLI with better error messages and debugging info
+-   **Configuration**: Dynamic config updates without requiring restarts
+-   **Build Process**: Faster and more reliable build pipeline
 
 ### 🧪 Testing & Validation
-- ✅ **Android Build**: Verified APK generation, installation, and runtime behavior
-- ✅ **iOS Build**: Tested build process and device compatibility  
-- ✅ **IP Detection**: Validated automatic network resolution across platforms
-- ✅ **Native Modules**: Confirmed API integration and performance benchmarks
-- ✅ **CLI Operations**: Tested enhanced command-line workflows and error handling
+
+-   ✅ **Android Build**: Verified APK generation, installation, and runtime behavior
+-   ✅ **iOS Build**: Tested build process and device compatibility
+-   ✅ **IP Detection**: Validated automatic network resolution across platforms
+-   ✅ **Native Modules**: Confirmed API integration and performance benchmarks
+-   ✅ **CLI Operations**: Tested enhanced command-line workflows and error handling
 
 ### 🔄 Breaking Changes
+
 **None** - All changes maintain backward compatibility while enhancing existing functionality
 
 ### 📝 Technical Details
-- Improved native API bridge for better cross-platform communication
-- Enhanced error reporting with detailed stack traces and suggestions
-- Optimized build configuration for faster development cycles
-- Added comprehensive logging for debugging and monitoring
+
+-   Improved native API bridge for better cross-platform communication
+-   Enhanced error reporting with detailed stack traces and suggestions
+-   Optimized build configuration for faster development cycles
+-   Added comprehensive logging for debugging and monitoring
 
 ### 🔗 Migration Notes
-- No migration steps required
-- Existing projects will automatically benefit from improvements
-- Optional: Update CLI usage to leverage new enhanced features
+
+-   No migration steps required
+-   Existing projects will automatically benefit from improvements
+-   Optional: Update CLI usage to leverage new enhanced features
+
 ## Version
-- Target version: 0.0.3-canary.7
+
+-   Target version: 0.0.3-canary.7

package/dist/native/androidProject/.idea/misc.xml

@@ -1,3 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="jbr-21" project-jdk-type="JavaSDK" />

package/dist/native/androidProject/app/build.gradle.kts

@@ -1,6 +1,14 @@
 import java.net.NetworkInterface
 import java.io.File
 import java.util.Properties
+import org.json.JSONObject
+import org.json.JSONArray
+
+buildscript {
+    dependencies {
+        classpath("org.json:json:20231013")
+    }
+}
 
 val configPath: String? by project.properties
 val keystorePassword: String? by project.properties  // Changed from keyStorePassword to keystorePassword
@@ -133,6 +141,7 @@ dependencies {
     androidTestImplementation(libs.androidx.espresso.core)
     implementation("androidx.webkit:webkit:1.12.1")
     implementation("org.json:json:20231013")
+    implementation("androidx.core:core-splashscreen:1.0.1")
     
     // Ktor Server dependencies for FrameworkServer (~200KB total)
     implementation("io.ktor:ktor-server-core:2.3.7")
@@ -196,12 +205,15 @@ tasks.register("generateWebViewConfig") {
         }
 
         val configContent = configJsonFile.readText()
-
-        // Extract WEBVIEW_CONFIG section
-        val webviewConfigRegex = """"WEBVIEW_CONFIG"\s*:\s*\{([^}]*)\}""".toRegex()
-        val webviewConfigMatch = webviewConfigRegex.find(configContent)
-        val webviewConfigContent = webviewConfigMatch?.groupValues?.get(1)
-
+        
+        val jsonObject = JSONObject(configContent)
+        
+        if (!jsonObject.has("WEBVIEW_CONFIG")) {
+            throw GradleException("WEBVIEW_CONFIG not found in config file")
+        }
+        
+        val webviewConfig = jsonObject.getJSONObject("WEBVIEW_CONFIG")
+        
         val properties = Properties()
 
         // Set different IP based on build type
@@ -215,30 +227,36 @@ tasks.register("generateWebViewConfig") {
             properties.setProperty("buildOptimisation", "false")
         }
 
-        // Parse top-level properties
-        val topLevelRegex = """"([^"]+)"\s*:\s*"([^"]+)"""".toRegex()
-        webviewConfigContent?.let {
-            topLevelRegex.findAll(it).forEach { matchResult ->
-                val (key, value) = matchResult.destructured
-                if (key != "android") {
-                    properties.setProperty(key, value)
+        fun extractProperties(jsonObj: org.json.JSONObject, prefix: String = "") {
+            try {
+                val keys = jsonObj.keys()
+        
+                while (keys.hasNext()) {
+                    val key = keys.next()
+                    val value = jsonObj.opt(key)
+                    val fullKey = if (prefix.isEmpty()) key else "$prefix.$key"
+                    
+                    when (value) {
+                        is org.json.JSONObject -> {
+                            extractProperties(value, fullKey)
+                        }
+                        is org.json.JSONArray -> {
+                            val arrayValues = (0 until value.length()).map { i ->
+                                value.opt(i).toString()
+                            }.joinToString(",")
+                            properties.setProperty(fullKey, arrayValues)
+                        }
+                        else -> {
+                            properties.setProperty(fullKey, value.toString())
+                        }
+                    }
                 }
+            } catch (e: Exception) {
+                throw RuntimeException("Failed to extract properties from JSON at prefix: $prefix", e)
             }
         }
 
-        // Parse android object specifically
-        val androidRegex = """"android"\s*:\s*\{([^}]*)\}""".toRegex()
-        val androidMatch = androidRegex.find(webviewConfigContent ?: "")
-        val androidContent = androidMatch?.groupValues?.get(1)
-
-        // Parse android object properties
-        val androidPropsRegex = """"([^"]+)"\s*:\s*"([^"]+)"""".toRegex()
-        androidContent?.let {
-            androidPropsRegex.findAll(it).forEach { matchResult ->
-                val (key, value) = matchResult.destructured
-                properties.setProperty("android.$key", value)
-            }
-        }
+        extractProperties(webviewConfig)
 
         // Set production-specific properties for release builds
         if (gradle.startParameter.taskNames.any { it.contains("Release") || it.contains("release") }) {

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/CustomWebview.kt

@@ -2,6 +2,7 @@ package io.yourname.androidproject
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.content.Intent
 import android.graphics.Bitmap
 import android.net.Uri
 import android.os.Bundle
@@ -11,6 +12,8 @@ import android.webkit.*
 import android.widget.ProgressBar
 import androidx.webkit.WebViewAssetLoader
 import io.yourname.androidproject.WebCacheManager
+import io.yourname.androidproject.isUrlAllowed
+import io.yourname.androidproject.isExternalDomain
 import kotlinx.coroutines.*
 import java.util.Properties
 
@@ -34,6 +37,7 @@ class CustomWebView(
     private var isInitialPageLoaded: Boolean = false
     private var buildOptimisation: Boolean = false // Added property for build optimization
     private lateinit var assetLoader: WebViewAssetLoader
+    private var allowedUrls: List<String> = emptyList()
 
     // Counters for asset loading statistics
     private var assetLoadAttempts = 0
@@ -56,6 +60,12 @@ class CustomWebView(
         // Parse buildOptimisation property
         buildOptimisation = properties.getProperty("buildOptimisation", "false").toBoolean()
 
+        // Load allowed URLs from properties
+        allowedUrls = properties.getProperty("accessControl.allowedUrls", "")
+            .split(",")
+            .map { it.trim() }
+            .filter { it.isNotEmpty() }
+
         // Set initial flags based on buildOptimisation
         if (buildOptimisation) {
             isInitialApiCalled = false
@@ -71,6 +81,7 @@ class CustomWebView(
             Log.d(TAG, "Cache Pattern: $cachePatterns")
             Log.d(TAG, "API Base URL: $apiBaseUrl")
             Log.d(TAG, "Build Optimisation: $buildOptimisation")
+            Log.d(TAG, "Allowed URLs: $allowedUrls")
             Log.d(TAG, "Initial API Called: $isInitialApiCalled")
             Log.d(TAG, "Initial Page Loaded: $isInitialPageLoaded")
         }
@@ -198,6 +209,22 @@ class CustomWebView(
         }
     }
 
+
+
+    private fun openInInAppBrowser(url: String) {
+        try {
+            val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            context.startActivity(intent)
+            if (BuildConfig.DEBUG) {
+                Log.d(TAG, "🌐 Opening external URL in in-app browser: $url")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ Failed to open URL in in-app browser: $url", e)
+        }
+    }
+    
+
     private fun isApiCall(url: String): Boolean {
         // Check if URL is an API call based on your API base URL
         return apiBaseUrl.isNotEmpty() && url.startsWith(apiBaseUrl)
@@ -290,6 +317,25 @@ class CustomWebView(
         webView.webViewClient = object : WebViewClient() {
             override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
                 request?.url?.let { url ->
+                    val urlString = url.toString()
+                    
+                    // Check if URL is an external domain
+                    if (url.scheme in listOf("http", "https") && isExternalDomain(urlString, allowedUrls)) {
+                        if (BuildConfig.DEBUG) {
+                            Log.d(TAG, "🌍 External domain detected, opening in in-app browser: $urlString")
+                        }
+                        openInInAppBrowser(urlString)
+                        return true
+                    }
+                    
+                    // Check if URL is allowed for internal navigation
+                    if (!isUrlAllowed(urlString, allowedUrls)) {
+                        if (BuildConfig.DEBUG) {
+                            Log.w(TAG, "🚫 URL blocked by access control: $urlString")
+                        }
+                        return true
+                    }
+                    
                     // Let WebView handle loading non-API HTTP/HTTPS URLs
                     if (url.scheme in listOf("http", "https")) {
                         return false
@@ -307,6 +353,14 @@ class CustomWebView(
                     Log.d(TAG, "🔄 Intercepting request for: $url on thread: ${Thread.currentThread().name}")
                 }
 
+                if (!isUrlAllowed(url, allowedUrls)) {
+                    if (BuildConfig.DEBUG) {
+                        Log.w(TAG, "🚫 Network request blocked by access control: $url")
+                    }
+                    // Return an empty response to block the request
+                    return WebResourceResponse("text/plain", "utf-8", null)
+                }
+
                 // Handle the initial route request - intercept first request regardless of host
                 if (!isInitialApiCalled && request.method == "GET") {
                     isInitialApiCalled = true

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/MainActivity.kt

@@ -10,6 +10,7 @@ import io.yourname.androidproject.NativeBridge
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.MainScope
 import kotlinx.coroutines.cancelChildren
+import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 
 class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
 
@@ -20,6 +21,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
     private lateinit var properties: Properties
     private var isHardwareAccelerationEnabled = false
     private var currentUrl: String = ""
+    private var splashStartTime: Long = 0
 
     private fun enableHardwareAcceleration() {
         if (!isHardwareAccelerationEnabled) {
@@ -45,6 +47,7 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
     }
 
     override fun onCreate(savedInstanceState: Bundle?) {
+        val splashScreen = installSplashScreen()
         super.onCreate(savedInstanceState)
         if (BuildConfig.DEBUG) {
             Log.d(TAG, "📱 onCreate started on thread: ${Thread.currentThread().name}")
@@ -63,6 +66,10 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
             properties.setProperty("buildOptimisation", (!BuildConfig.DEBUG).toString())
         }
 
+        // Configure splash screen
+        splashStartTime = System.currentTimeMillis()
+        configureSplashScreen(splashScreen)
+
         // Setup UI
         binding = ActivityMainBinding.inflate(layoutInflater)
         supportActionBar?.hide()
@@ -159,4 +166,21 @@ class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
         customWebView.destroy()
         super.onDestroy()
     }
+
+    private fun configureSplashScreen(splashScreen: androidx.core.splashscreen.SplashScreen) {
+        val durationProperty = properties.getProperty("splashScreen.duration")
+        
+        splashScreen.setKeepOnScreenCondition {
+            val webViewLoaded = ::customWebView.isInitialized && 
+                               customWebView.getWebView().progress >= 100
+            
+            if (durationProperty != null) {
+                val duration = durationProperty.toLong()
+                val timeElapsed = System.currentTimeMillis() - splashStartTime >= duration
+                !timeElapsed
+            } else {
+                !webViewLoaded
+            }
+        }
+    }
 }

package/dist/native/bridge/WebBridge.js

@@ -1,14 +1,14 @@
 "use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.default=void 0;var _NativeInterfaces=require("./constants/NativeInterfaces.js");class WebBridge{constructor(){this.handlers=new Map();this.initialized=false;this._logInitialization();}/**
      * Log initialization info
-     */_logInitialization(){console.log("🌉 WebBridge initialized");console.log("🌉 Available callback interfaces:",_NativeInterfaces.ALL_CALLBACKS.length);if(process.env.NODE_ENV==='development'){(0,_NativeInterfaces.debugInterfaces)();}}/**
+     */_logInitialization(){console.log("🌉 WebBridge initialized");console.log("🌉 Available callback interfaces:",_NativeInterfaces.ALL_CALLBACKS.length);if(process.env.NODE_ENV==="development"){(0,_NativeInterfaces.debugInterfaces)();}}/**
      * Static method to initialize WebBridge on window object
-     */static init=()=>{if(typeof window==='undefined'){console.error("🌉 WebBridge cannot be initialized outside the browser!");return null;}if(window.WebBridge){console.warn("🌉 WebBridge already initialized!");return window.WebBridge;}const bridge=new WebBridge();window.WebBridge=bridge;bridge.initialized=true;console.log("🌉 WebBridge created and attached to window");return bridge;};/**
+     */static init=()=>{if(typeof window==="undefined"){console.error("🌉 WebBridge cannot be initialized outside the browser!");return null;}if(window.WebBridge){console.warn("🌉 WebBridge already initialized!");return window.WebBridge;}const bridge=new WebBridge();window.WebBridge=bridge;bridge.initialized=true;console.log("🌉 WebBridge created and attached to window");return bridge;};/**
      * Main callback handler called by native platforms
      * @param {string} interfaceName - The callback interface name
      * @param {any} data - Data from native platform
-     */callback=(interfaceName,data)=>{console.log(`🌉 WebBridge callback: ${interfaceName}`,data?{data}:'');// Validate interface
+     */callback=(interfaceName,data)=>{console.log(`🌉 WebBridge callback: ${interfaceName}`,data?{data}:"");// Validate interface
 if(!(0,_NativeInterfaces.isValidCallback)(interfaceName)){console.error(`🌉 Invalid callback interface: ${interfaceName}`);console.log("🌉 Available callbacks:",_NativeInterfaces.ALL_CALLBACKS);return;}if(!this.handlers.has(interfaceName)){console.warn(`🌉 No handler registered for interface: ${interfaceName}`);return;}try{const handler=this.handlers.get(interfaceName);handler(data);}catch(error){console.error(`🌉 Error executing callback for ${interfaceName}:`,error);// In development, provide more helpful error info
-if(process.env.NODE_ENV==='development'){console.error('🌉 Handler details:',{interfaceName,data,handlerType:typeof this.handlers.get(interfaceName)});}}};/**
+if(process.env.NODE_ENV==="development"){console.error("🌉 Handler details:",{interfaceName,data,handlerType:typeof this.handlers.get(interfaceName)});}}};/**
      * Register a callback handler for a native interface
      * @param {string} interfaceName - The callback interface name (from NATIVE_CALLBACKS)
      * @param {function} callback - The callback function to execute
@@ -39,4 +39,4 @@ if(this.handlers.has(interfaceName)){console.warn(`🌉 Interface ${interfaceNam
      * Test callback functionality (for debugging)
      * @param {string} interfaceName - The callback interface to test
      * @param {any} testData - Test data to pass
-     */testCallback=(interfaceName,testData='test')=>{if(process.env.NODE_ENV!=='development'){console.warn('🌉 testCallback is only available in development mode');return;}console.log(`🌉 Testing callback: ${interfaceName}`);this.callback(interfaceName,testData);};}var _default=exports.default=WebBridge;
+     */testCallback=(interfaceName,testData="test")=>{if(process.env.NODE_ENV!=="development"){console.warn("🌉 testCallback is only available in development mode");return;}console.log(`🌉 Testing callback: ${interfaceName}`);this.callback(interfaceName,testData);};}var _default=exports.default=WebBridge;

package/dist/native/bridge/constants/NativeInterfaces.js

@@ -2,21 +2,21 @@
 // Centralized definitions for all native interface communications
 // Command Interfaces: Web → Native (outgoing commands)
 const NATIVE_COMMANDS=exports.NATIVE_COMMANDS={// Camera commands
-OPEN_CAMERA:'openCamera',REQUEST_CAMERA_PERMISSION:'requestCameraPermission',// File commands
-PICK_FILE:'pickFile',OPEN_FILE_WITH_INTENT:'openFileWithIntent',// Haptic feedback commands
-REQUEST_HAPTIC_FEEDBACK:'requestHapticFeedback'};// Callback Interfaces: Native → Web (incoming events/callbacks)
+OPEN_CAMERA:"openCamera",REQUEST_CAMERA_PERMISSION:"requestCameraPermission",// File commands
+PICK_FILE:"pickFile",OPEN_FILE_WITH_INTENT:"openFileWithIntent",// Haptic feedback commands
+REQUEST_HAPTIC_FEEDBACK:"requestHapticFeedback"};// Callback Interfaces: Native → Web (incoming events/callbacks)
 const NATIVE_CALLBACKS=exports.NATIVE_CALLBACKS={// Camera callbacks
-CAMERA_PERMISSION_STATUS:'CAMERA_PERMISSION_STATUS',ON_CAMERA_CAPTURE:'ON_CAMERA_CAPTURE',ON_CAMERA_ERROR:'ON_CAMERA_ERROR',// File picker callbacks
-ON_FILE_PICKED:'ON_FILE_PICKED',ON_FILE_PICK_ERROR:'ON_FILE_PICK_ERROR',ON_FILE_PICK_CANCELLED:'ON_FILE_PICK_CANCELLED',ON_FILE_PICK_STATE_UPDATE:'ON_FILE_PICK_STATE_UPDATE',// Intent callbacks
-ON_INTENT_SUCCESS:'ON_INTENT_SUCCESS',ON_INTENT_ERROR:'ON_INTENT_ERROR',ON_INTENT_CANCELLED:'ON_INTENT_CANCELLED',// Haptic feedback callbacks
-HAPTIC_FEEDBACK:'HAPTIC_FEEDBACK'};// Interface Categories for easier management
+CAMERA_PERMISSION_STATUS:"CAMERA_PERMISSION_STATUS",ON_CAMERA_CAPTURE:"ON_CAMERA_CAPTURE",ON_CAMERA_ERROR:"ON_CAMERA_ERROR",// File picker callbacks
+ON_FILE_PICKED:"ON_FILE_PICKED",ON_FILE_PICK_ERROR:"ON_FILE_PICK_ERROR",ON_FILE_PICK_CANCELLED:"ON_FILE_PICK_CANCELLED",ON_FILE_PICK_STATE_UPDATE:"ON_FILE_PICK_STATE_UPDATE",// Intent callbacks
+ON_INTENT_SUCCESS:"ON_INTENT_SUCCESS",ON_INTENT_ERROR:"ON_INTENT_ERROR",ON_INTENT_CANCELLED:"ON_INTENT_CANCELLED",// Haptic feedback callbacks
+HAPTIC_FEEDBACK:"HAPTIC_FEEDBACK"};// Interface Categories for easier management
 const INTERFACE_CATEGORIES=exports.INTERFACE_CATEGORIES={CAMERA:{commands:[NATIVE_COMMANDS.OPEN_CAMERA,NATIVE_COMMANDS.REQUEST_CAMERA_PERMISSION],callbacks:[NATIVE_CALLBACKS.CAMERA_PERMISSION_STATUS,NATIVE_CALLBACKS.ON_CAMERA_CAPTURE,NATIVE_CALLBACKS.ON_CAMERA_ERROR]},FILE:{commands:[NATIVE_COMMANDS.PICK_FILE,NATIVE_COMMANDS.OPEN_FILE_WITH_INTENT],callbacks:[NATIVE_CALLBACKS.ON_FILE_PICKED,NATIVE_CALLBACKS.ON_FILE_PICK_ERROR,NATIVE_CALLBACKS.ON_FILE_PICK_CANCELLED,NATIVE_CALLBACKS.ON_FILE_PICK_STATE_UPDATE]},INTENT:{commands:[NATIVE_COMMANDS.OPEN_FILE_WITH_INTENT],callbacks:[NATIVE_CALLBACKS.ON_INTENT_SUCCESS,NATIVE_CALLBACKS.ON_INTENT_ERROR,NATIVE_CALLBACKS.ON_INTENT_CANCELLED]},HAPTIC:{commands:[NATIVE_COMMANDS.REQUEST_HAPTIC_FEEDBACK],callbacks:[NATIVE_CALLBACKS.HAPTIC_FEEDBACK]}};// All available interfaces (for validation)
 const ALL_COMMANDS=exports.ALL_COMMANDS=Object.values(NATIVE_COMMANDS);const ALL_CALLBACKS=exports.ALL_CALLBACKS=Object.values(NATIVE_CALLBACKS);const ALL_INTERFACES=exports.ALL_INTERFACES=[...ALL_COMMANDS,...ALL_CALLBACKS];// Permission status constants
-const PERMISSION_STATUS=exports.PERMISSION_STATUS={GRANTED:'GRANTED',DENIED:'DENIED',NOT_DETERMINED:'NOT_DETERMINED',RESTRICTED:'RESTRICTED'};// Haptic feedback types
-const HAPTIC_FEEDBACK_TYPES=exports.HAPTIC_FEEDBACK_TYPES={LIGHT:'light',MEDIUM:'medium',HEAVY:'heavy',SUCCESS:'success',WARNING:'warning',ERROR:'error'};// File picker state constants
-const FILE_PICKER_STATES=exports.FILE_PICKER_STATES={OPENING:'opening',PROCESSING:'processing',IDLE:null};// Intent processing states
-const INTENT_STATES=exports.INTENT_STATES={PROCESSING:'processing',DOWNLOADING:'downloading',OPENING:'opening',IDLE:null};// Response status constants
-const RESPONSE_STATUS=exports.RESPONSE_STATUS={SUCCESS:'SUCCESS',ERROR:'ERROR',CANCELLED:'CANCELLED'};// Utility functions for interface validation
+const PERMISSION_STATUS=exports.PERMISSION_STATUS={GRANTED:"GRANTED",DENIED:"DENIED",NOT_DETERMINED:"NOT_DETERMINED",RESTRICTED:"RESTRICTED"};// Haptic feedback types
+const HAPTIC_FEEDBACK_TYPES=exports.HAPTIC_FEEDBACK_TYPES={LIGHT:"light",MEDIUM:"medium",HEAVY:"heavy",SUCCESS:"success",WARNING:"warning",ERROR:"error"};// File picker state constants
+const FILE_PICKER_STATES=exports.FILE_PICKER_STATES={OPENING:"opening",PROCESSING:"processing",IDLE:null};// Intent processing states
+const INTENT_STATES=exports.INTENT_STATES={PROCESSING:"processing",DOWNLOADING:"downloading",OPENING:"opening",IDLE:null};// Response status constants
+const RESPONSE_STATUS=exports.RESPONSE_STATUS={SUCCESS:"SUCCESS",ERROR:"ERROR",CANCELLED:"CANCELLED"};// Utility functions for interface validation
 const isValidCommand=command=>ALL_COMMANDS.includes(command);exports.isValidCommand=isValidCommand;const isValidCallback=callback=>ALL_CALLBACKS.includes(callback);exports.isValidCallback=isValidCallback;const isValidInterface=interfaceName=>ALL_INTERFACES.includes(interfaceName);// Get interfaces by category
 exports.isValidInterface=isValidInterface;const getInterfacesByCategory=category=>{const categoryData=INTERFACE_CATEGORIES[category.toUpperCase()];if(!categoryData){throw new Error(`Invalid category: ${category}`);}return categoryData;};// Debug helper to list all interfaces
-exports.getInterfacesByCategory=getInterfacesByCategory;const debugInterfaces=()=>{console.group('🌉 Native Bridge Interfaces');console.log('Commands:',ALL_COMMANDS);console.log('Callbacks:',ALL_CALLBACKS);console.log('Categories:',Object.keys(INTERFACE_CATEGORIES));console.groupEnd();};exports.debugInterfaces=debugInterfaces;var _default=exports.default={NATIVE_COMMANDS,NATIVE_CALLBACKS,INTERFACE_CATEGORIES,ALL_COMMANDS,ALL_CALLBACKS,ALL_INTERFACES,PERMISSION_STATUS,HAPTIC_FEEDBACK_TYPES,FILE_PICKER_STATES,INTENT_STATES,RESPONSE_STATUS,isValidCommand,isValidCallback,isValidInterface,getInterfacesByCategory,debugInterfaces};
+exports.getInterfacesByCategory=getInterfacesByCategory;const debugInterfaces=()=>{console.group("🌉 Native Bridge Interfaces");console.log("Commands:",ALL_COMMANDS);console.log("Callbacks:",ALL_CALLBACKS);console.log("Categories:",Object.keys(INTERFACE_CATEGORIES));console.groupEnd();};exports.debugInterfaces=debugInterfaces;var _default=exports.default={NATIVE_COMMANDS,NATIVE_CALLBACKS,INTERFACE_CATEGORIES,ALL_COMMANDS,ALL_CALLBACKS,ALL_INTERFACES,PERMISSION_STATUS,HAPTIC_FEEDBACK_TYPES,FILE_PICKER_STATES,INTENT_STATES,RESPONSE_STATUS,isValidCommand,isValidCallback,isValidInterface,getInterfacesByCategory,debugInterfaces};

package/dist/native/bridge/errors.js

@@ -2,16 +2,16 @@
  * Standardized Error System for Catalyst Framework
  * Translates native errors into web developer-friendly messages
  */// Error categories for logical grouping
-const ERROR_CATEGORIES=exports.ERROR_CATEGORIES={PERMISSION:'PERMISSION',NETWORK:'NETWORK',FILE_SYSTEM:'FILE_SYSTEM',USER_ACTION:'USER_ACTION',VALIDATION:'VALIDATION',SYSTEM:'SYSTEM',UNKNOWN:'UNKNOWN'};// Standardized error codes
+const ERROR_CATEGORIES=exports.ERROR_CATEGORIES={PERMISSION:"PERMISSION",NETWORK:"NETWORK",FILE_SYSTEM:"FILE_SYSTEM",USER_ACTION:"USER_ACTION",VALIDATION:"VALIDATION",SYSTEM:"SYSTEM",UNKNOWN:"UNKNOWN"};// Standardized error codes
 const ERROR_CODES=exports.ERROR_CODES={// Permission errors
-PERMISSION_DENIED:'PERMISSION_DENIED',PERMISSION_REQUIRED:'PERMISSION_REQUIRED',// Network errors
-NETWORK_UNAVAILABLE:'NETWORK_UNAVAILABLE',DOWNLOAD_FAILED:'DOWNLOAD_FAILED',// File system errors
-FILE_NOT_FOUND:'FILE_NOT_FOUND',FILE_TOO_LARGE:'FILE_TOO_LARGE',STORAGE_FULL:'STORAGE_FULL',FILE_CORRUPTED:'FILE_CORRUPTED',// User action errors
-OPERATION_CANCELLED:'OPERATION_CANCELLED',NO_FILE_SELECTED:'NO_FILE_SELECTED',// Validation errors
-INVALID_FILE_TYPE:'INVALID_FILE_TYPE',INVALID_PARAMETERS:'INVALID_PARAMETERS',// System errors
-BRIDGE_UNAVAILABLE:'BRIDGE_UNAVAILABLE',FEATURE_UNSUPPORTED:'FEATURE_UNSUPPORTED',INTERNAL_ERROR:'INTERNAL_ERROR',// Camera specific errors
-CAMERA_UNAVAILABLE:'CAMERA_UNAVAILABLE',CAMERA_IN_USE:'CAMERA_IN_USE'};// Error definitions with user-friendly messages and recovery actions
-const ERROR_DEFINITIONS=exports.ERROR_DEFINITIONS={[ERROR_CODES.PERMISSION_DENIED]:{category:ERROR_CATEGORIES.PERMISSION,defaultMessage:'Permission denied',defaultDetails:'Required permission was not granted by the user',recoverable:true,suggestedAction:'Grant permission in device settings and try again'},[ERROR_CODES.PERMISSION_REQUIRED]:{category:ERROR_CATEGORIES.PERMISSION,defaultMessage:'Permission required',defaultDetails:'This operation requires additional permissions',recoverable:true,suggestedAction:'Grant the required permission to continue'},[ERROR_CODES.NETWORK_UNAVAILABLE]:{category:ERROR_CATEGORIES.NETWORK,defaultMessage:'No internet connection',defaultDetails:'Network connection is required for this operation',recoverable:true,suggestedAction:'Check your internet connection and try again'},[ERROR_CODES.FILE_NOT_FOUND]:{category:ERROR_CATEGORIES.FILE_SYSTEM,defaultMessage:'File not found',defaultDetails:'The requested file could not be located',recoverable:false,suggestedAction:'The file may have been moved or deleted'},[ERROR_CODES.FILE_TOO_LARGE]:{category:ERROR_CATEGORIES.VALIDATION,defaultMessage:'File too large',defaultDetails:'File exceeds the maximum size limit',recoverable:true,suggestedAction:'Choose a smaller file or compress the current file'},[ERROR_CODES.STORAGE_FULL]:{category:ERROR_CATEGORIES.FILE_SYSTEM,defaultMessage:'Storage full',defaultDetails:'Device storage is full and cannot save the file',recoverable:true,suggestedAction:'Free up some storage space and try again'},[ERROR_CODES.OPERATION_CANCELLED]:{category:ERROR_CATEGORIES.USER_ACTION,defaultMessage:'Operation cancelled',defaultDetails:'The operation was cancelled by the user',recoverable:true,suggestedAction:'Try again if you want to complete the operation'},[ERROR_CODES.INVALID_FILE_TYPE]:{category:ERROR_CATEGORIES.VALIDATION,defaultMessage:'Invalid file type',defaultDetails:'The selected file type is not supported',recoverable:true,suggestedAction:'Choose a file with a supported format'},[ERROR_CODES.BRIDGE_UNAVAILABLE]:{category:ERROR_CATEGORIES.SYSTEM,defaultMessage:'Native feature unavailable',defaultDetails:'The native bridge is not available or not initialized',recoverable:false,suggestedAction:'Use web fallback if available'},[ERROR_CODES.FEATURE_UNSUPPORTED]:{category:ERROR_CATEGORIES.SYSTEM,defaultMessage:'Feature not supported',defaultDetails:'This feature is not supported on the current platform',recoverable:false,suggestedAction:'Try using an alternative method or device'},[ERROR_CODES.CAMERA_UNAVAILABLE]:{category:ERROR_CATEGORIES.SYSTEM,defaultMessage:'Camera unavailable',defaultDetails:'Camera hardware is not available or accessible',recoverable:false,suggestedAction:'Check if your device has a camera and try again'},[ERROR_CODES.CAMERA_IN_USE]:{category:ERROR_CATEGORIES.SYSTEM,defaultMessage:'Camera in use',defaultDetails:'Camera is being used by another application',recoverable:true,suggestedAction:'Close other camera apps and try again'},[ERROR_CODES.INTERNAL_ERROR]:{category:ERROR_CATEGORIES.UNKNOWN,defaultMessage:'An unexpected error occurred',defaultDetails:'An internal error occurred while processing the request',recoverable:true,suggestedAction:'Try again or contact support if the problem persists'}};/**
+PERMISSION_DENIED:"PERMISSION_DENIED",PERMISSION_REQUIRED:"PERMISSION_REQUIRED",// Network errors
+NETWORK_UNAVAILABLE:"NETWORK_UNAVAILABLE",DOWNLOAD_FAILED:"DOWNLOAD_FAILED",// File system errors
+FILE_NOT_FOUND:"FILE_NOT_FOUND",FILE_TOO_LARGE:"FILE_TOO_LARGE",STORAGE_FULL:"STORAGE_FULL",FILE_CORRUPTED:"FILE_CORRUPTED",// User action errors
+OPERATION_CANCELLED:"OPERATION_CANCELLED",NO_FILE_SELECTED:"NO_FILE_SELECTED",// Validation errors
+INVALID_FILE_TYPE:"INVALID_FILE_TYPE",INVALID_PARAMETERS:"INVALID_PARAMETERS",// System errors
+BRIDGE_UNAVAILABLE:"BRIDGE_UNAVAILABLE",FEATURE_UNSUPPORTED:"FEATURE_UNSUPPORTED",INTERNAL_ERROR:"INTERNAL_ERROR",// Camera specific errors
+CAMERA_UNAVAILABLE:"CAMERA_UNAVAILABLE",CAMERA_IN_USE:"CAMERA_IN_USE"};// Error definitions with user-friendly messages and recovery actions
+const ERROR_DEFINITIONS=exports.ERROR_DEFINITIONS={[ERROR_CODES.PERMISSION_DENIED]:{category:ERROR_CATEGORIES.PERMISSION,defaultMessage:"Permission denied",defaultDetails:"Required permission was not granted by the user",recoverable:true,suggestedAction:"Grant permission in device settings and try again"},[ERROR_CODES.PERMISSION_REQUIRED]:{category:ERROR_CATEGORIES.PERMISSION,defaultMessage:"Permission required",defaultDetails:"This operation requires additional permissions",recoverable:true,suggestedAction:"Grant the required permission to continue"},[ERROR_CODES.NETWORK_UNAVAILABLE]:{category:ERROR_CATEGORIES.NETWORK,defaultMessage:"No internet connection",defaultDetails:"Network connection is required for this operation",recoverable:true,suggestedAction:"Check your internet connection and try again"},[ERROR_CODES.FILE_NOT_FOUND]:{category:ERROR_CATEGORIES.FILE_SYSTEM,defaultMessage:"File not found",defaultDetails:"The requested file could not be located",recoverable:false,suggestedAction:"The file may have been moved or deleted"},[ERROR_CODES.FILE_TOO_LARGE]:{category:ERROR_CATEGORIES.VALIDATION,defaultMessage:"File too large",defaultDetails:"File exceeds the maximum size limit",recoverable:true,suggestedAction:"Choose a smaller file or compress the current file"},[ERROR_CODES.STORAGE_FULL]:{category:ERROR_CATEGORIES.FILE_SYSTEM,defaultMessage:"Storage full",defaultDetails:"Device storage is full and cannot save the file",recoverable:true,suggestedAction:"Free up some storage space and try again"},[ERROR_CODES.OPERATION_CANCELLED]:{category:ERROR_CATEGORIES.USER_ACTION,defaultMessage:"Operation cancelled",defaultDetails:"The operation was cancelled by the user",recoverable:true,suggestedAction:"Try again if you want to complete the operation"},[ERROR_CODES.INVALID_FILE_TYPE]:{category:ERROR_CATEGORIES.VALIDATION,defaultMessage:"Invalid file type",defaultDetails:"The selected file type is not supported",recoverable:true,suggestedAction:"Choose a file with a supported format"},[ERROR_CODES.BRIDGE_UNAVAILABLE]:{category:ERROR_CATEGORIES.SYSTEM,defaultMessage:"Native feature unavailable",defaultDetails:"The native bridge is not available or not initialized",recoverable:false,suggestedAction:"Use web fallback if available"},[ERROR_CODES.FEATURE_UNSUPPORTED]:{category:ERROR_CATEGORIES.SYSTEM,defaultMessage:"Feature not supported",defaultDetails:"This feature is not supported on the current platform",recoverable:false,suggestedAction:"Try using an alternative method or device"},[ERROR_CODES.CAMERA_UNAVAILABLE]:{category:ERROR_CATEGORIES.SYSTEM,defaultMessage:"Camera unavailable",defaultDetails:"Camera hardware is not available or accessible",recoverable:false,suggestedAction:"Check if your device has a camera and try again"},[ERROR_CODES.CAMERA_IN_USE]:{category:ERROR_CATEGORIES.SYSTEM,defaultMessage:"Camera in use",defaultDetails:"Camera is being used by another application",recoverable:true,suggestedAction:"Close other camera apps and try again"},[ERROR_CODES.INTERNAL_ERROR]:{category:ERROR_CATEGORIES.UNKNOWN,defaultMessage:"An unexpected error occurred",defaultDetails:"An internal error occurred while processing the request",recoverable:true,suggestedAction:"Try again or contact support if the problem persists"}};/**
  * Create a standardized error object
  * @param {string} code - Error code from ERROR_CODES
  * @param {string} userMessage - Custom user-friendly message (optional)
@@ -23,17 +23,17 @@ const ERROR_DEFINITIONS=exports.ERROR_DEFINITIONS={[ERROR_CODES.PERMISSION_DENIE
  * @param {any} nativeError - Native error from Android/iOS
  * @returns {Object} Standardized error object
  */exports.createStandardError=createStandardError;const translateError=nativeError=>{if(!nativeError){return createStandardError(ERROR_CODES.INTERNAL_ERROR,null,nativeError);}const errorString=nativeError.toString().toLowerCase();// Permission errors
-if(errorString.includes('permission')&&errorString.includes('denied')){if(errorString.includes('camera')){return createStandardError(ERROR_CODES.PERMISSION_DENIED,'Camera permission denied',nativeError);}if(errorString.includes('storage')||errorString.includes('external_storage')){return createStandardError(ERROR_CODES.PERMISSION_DENIED,'Storage permission denied',nativeError);}return createStandardError(ERROR_CODES.PERMISSION_DENIED,null,nativeError);}// File system errors
-if(errorString.includes('filenotfound')||errorString.includes('file not found')){return createStandardError(ERROR_CODES.FILE_NOT_FOUND,null,nativeError);}if(errorString.includes('storage')&&errorString.includes('full')){return createStandardError(ERROR_CODES.STORAGE_FULL,null,nativeError);}// Network errors
-if(errorString.includes('network')||errorString.includes('connection')||errorString.includes('internet')){return createStandardError(ERROR_CODES.NETWORK_UNAVAILABLE,null,nativeError);}// User cancellation
-if(errorString.includes('cancel')||errorString.includes('abort')){return createStandardError(ERROR_CODES.OPERATION_CANCELLED,null,nativeError);}// Camera specific errors
-if(errorString.includes('camera')){if(errorString.includes('unavailable')||errorString.includes('not available')){return createStandardError(ERROR_CODES.CAMERA_UNAVAILABLE,null,nativeError);}if(errorString.includes('in use')||errorString.includes('busy')){return createStandardError(ERROR_CODES.CAMERA_IN_USE,null,nativeError);}}// Activity/Intent errors (Android)
-if(errorString.includes('activitynotfound')){return createStandardError(ERROR_CODES.FEATURE_UNSUPPORTED,'No app available to handle this request',nativeError);}// iOS specific error codes
-if(typeof nativeError==='object'&&nativeError.code&&nativeError.domain){// Camera errors (iOS)
-if(nativeError.domain==='AVCaptureSessionErrorDomain'){if(nativeError.code===-11814){return createStandardError(ERROR_CODES.PERMISSION_DENIED,'Camera access denied',nativeError);}}// Network errors (iOS)
-if(nativeError.domain==='NSURLErrorDomain'){if(nativeError.code===-1009){return createStandardError(ERROR_CODES.NETWORK_UNAVAILABLE,null,nativeError);}}// File system errors (iOS)
-if(nativeError.domain==='NSCocoaErrorDomain'){if(nativeError.code===260){return createStandardError(ERROR_CODES.FILE_NOT_FOUND,null,nativeError);}}}// Default to internal error
+if(errorString.includes("permission")&&errorString.includes("denied")){if(errorString.includes("camera")){return createStandardError(ERROR_CODES.PERMISSION_DENIED,"Camera permission denied",nativeError);}if(errorString.includes("storage")||errorString.includes("external_storage")){return createStandardError(ERROR_CODES.PERMISSION_DENIED,"Storage permission denied",nativeError);}return createStandardError(ERROR_CODES.PERMISSION_DENIED,null,nativeError);}// File system errors
+if(errorString.includes("filenotfound")||errorString.includes("file not found")){return createStandardError(ERROR_CODES.FILE_NOT_FOUND,null,nativeError);}if(errorString.includes("storage")&&errorString.includes("full")){return createStandardError(ERROR_CODES.STORAGE_FULL,null,nativeError);}// Network errors
+if(errorString.includes("network")||errorString.includes("connection")||errorString.includes("internet")){return createStandardError(ERROR_CODES.NETWORK_UNAVAILABLE,null,nativeError);}// User cancellation
+if(errorString.includes("cancel")||errorString.includes("abort")){return createStandardError(ERROR_CODES.OPERATION_CANCELLED,null,nativeError);}// Camera specific errors
+if(errorString.includes("camera")){if(errorString.includes("unavailable")||errorString.includes("not available")){return createStandardError(ERROR_CODES.CAMERA_UNAVAILABLE,null,nativeError);}if(errorString.includes("in use")||errorString.includes("busy")){return createStandardError(ERROR_CODES.CAMERA_IN_USE,null,nativeError);}}// Activity/Intent errors (Android)
+if(errorString.includes("activitynotfound")){return createStandardError(ERROR_CODES.FEATURE_UNSUPPORTED,"No app available to handle this request",nativeError);}// iOS specific error codes
+if(typeof nativeError==="object"&&nativeError.code&&nativeError.domain){// Camera errors (iOS)
+if(nativeError.domain==="AVCaptureSessionErrorDomain"){if(nativeError.code===-11814){return createStandardError(ERROR_CODES.PERMISSION_DENIED,"Camera access denied",nativeError);}}// Network errors (iOS)
+if(nativeError.domain==="NSURLErrorDomain"){if(nativeError.code===-1009){return createStandardError(ERROR_CODES.NETWORK_UNAVAILABLE,null,nativeError);}}// File system errors (iOS)
+if(nativeError.domain==="NSCocoaErrorDomain"){if(nativeError.code===260){return createStandardError(ERROR_CODES.FILE_NOT_FOUND,null,nativeError);}}}// Default to internal error
 return createStandardError(ERROR_CODES.INTERNAL_ERROR,null,nativeError);};/**
  * Check if development mode is enabled
  * @returns {boolean} True if in development mode
- */exports.translateError=translateError;const isDevelopment=()=>{return typeof process!=='undefined'&&process.env&&process.env.NODE_ENV==='development';};exports.isDevelopment=isDevelopment;
+ */exports.translateError=translateError;const isDevelopment=()=>{return typeof process!=="undefined"&&process.env&&process.env.NODE_ENV==="development";};exports.isDevelopment=isDevelopment;

package/dist/native/bridge/hooks.js

@@ -2,17 +2,17 @@
  * React hook for camera functionality using standardized interface
  * Handles camera permissions, photo capture, and error states
  */const useCamera=()=>{// Use standardized base hook
-const base=(0,_useBaseHook.useBaseHook)('useCamera');// Camera-specific state
+const base=(0,_useBaseHook.useBaseHook)("useCamera");// Camera-specific state
 const[permission,setPermission]=(0,_react.useState)(null);// Server-side rendering safety
 if(typeof window==="undefined"){return{data:null,loading:false,progress:null,error:null,isWeb:true,isNative:false,execute:()=>{},clear:()=>{},clearError:()=>{},permission:null,// Legacy aliases
 photo:null,takePhoto:()=>{},isLoading:false,clearPhoto:()=>{}};}if(!window.WebBridge){throw new Error("WebBridge is not initialized. Call WebBridge.init() first.");}(0,_react.useEffect)(()=>{// Register callback handlers
-window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_CAMERA_CAPTURE,data=>{try{const result=typeof data==='string'?JSON.parse(data):data;console.log("📷 Camera capture result:",result);// Handle new tri-transport format or legacy format
+window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_CAMERA_CAPTURE,data=>{try{const result=typeof data==="string"?JSON.parse(data):data;console.log("📷 Camera capture result:",result);// Handle new tri-transport format or legacy format
 const photoData=result.fileSrc?{// New tri-transport format
 fileSrc:result.fileSrc,fileName:result.fileName,size:result.size,mimeType:result.mimeType,transport:result.transport,source:result.source}:{// Legacy format (fallback)
-fileSrc:result.imageUrl,fileName:'camera_photo.jpg',size:0,mimeType:'image/jpeg',transport:'LEGACY',source:'camera'};base.setDataAndComplete(photoData);// Update progress with transport info if available
+fileSrc:result.imageUrl,fileName:"camera_photo.jpg",size:0,mimeType:"image/jpeg",transport:"LEGACY",source:"camera"};base.setDataAndComplete(photoData);// Update progress with transport info if available
 if(photoData.transport){base.updateProgress({transport:photoData.transport,bytesTotal:photoData.size||null});}console.log("📷 Photo captured successfully via transport:",photoData.transport);}catch(parseError){console.error("📷 Error parsing camera capture data:",parseError);base.handleNativeError("Failed to process captured photo");}});window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.CAMERA_PERMISSION_STATUS,data=>{setPermission(data);console.log("📷 Camera permission status:",data);});window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_CAMERA_ERROR,data=>{console.error("📷 Camera error:",data);base.handleNativeError(data);});return()=>{// Cleanup: unregister all handlers
 window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.CAMERA_PERMISSION_STATUS);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_CAMERA_CAPTURE);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_CAMERA_ERROR);};},[base.setDataAndComplete,base.handleNativeError,base.updateProgress]);const takePhoto=()=>{console.log("📷 Camera open requested");base.executeOperation(()=>{// Update progress to show capturing state
-base.updateProgress({state:'capturing',phase:'requesting',message:'Opening camera...'});_NativeBridge.default.camera.open();},'camera capture');};// Standardized execute function (new interface)
+base.updateProgress({state:"capturing",phase:"requesting",message:"Opening camera..."});_NativeBridge.default.camera.open();},"camera capture");};// Standardized execute function (new interface)
 const execute=takePhoto;return{// Standardized interface
 data:base.data,loading:base.loading,progress:base.progress,error:base.error,isWeb:base.isWeb,isNative:base.isNative,execute,clear:base.clear,clearError:base.clearError,// Camera-specific extras
 permission,// Legacy aliases for backward compatibility
@@ -20,28 +20,28 @@ photo:base.data,takePhoto,isLoading:base.loading,clearPhoto:base.clear};};/**
  * React hook for intent handling using standardized interface
  * Manages file opening operations with external apps
  */exports.useCamera=useCamera;const useIntent=()=>{// Use standardized base hook
-const base=(0,_useBaseHook.useBaseHook)('useIntent');// Server-side rendering safety
+const base=(0,_useBaseHook.useBaseHook)("useIntent");// Server-side rendering safety
 if(typeof window==="undefined"){return{data:null,loading:false,progress:null,error:null,isWeb:true,isNative:false,execute:()=>{},clear:()=>{},clearError:()=>{},// Legacy aliases
 isLoading:false,processingState:null,openFile:()=>{},success:null,reset:()=>{}};}if(!window.WebBridge){throw new Error("WebBridge is not initialized. Call WebBridge.init() first.");}(0,_react.useEffect)(()=>{// Register callback handlers
 window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_SUCCESS,data=>{console.log("📄 Intent completed successfully:",data);base.setDataAndComplete({result:data,success:true});});window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_ERROR,data=>{console.error("📄 Intent error:",data);base.handleNativeError(data);});window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_CANCELLED,data=>{console.log("📄 Intent cancelled:",data);base.setLoading(false);base.resetProgress();// Keep data as is when cancelled
 });return()=>{// Cleanup: unregister all handlers
 window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_SUCCESS);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_ERROR);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_CANCELLED);};},[base.setDataAndComplete,base.handleNativeError,base.setLoading,base.resetProgress]);const openFile=(fileUrl,mimeType=null)=>{if(!fileUrl){base.handleNativeError("File URL is required");return;}console.log("📄 File open with intent requested:",{fileUrl,mimeType});base.executeOperation(()=>{// Update progress to show opening state
-base.updateProgress({state:'opening_file',phase:'processing',message:'Opening file with external app...'});_NativeBridge.default.file.openWithIntent(fileUrl,mimeType);},'intent file open');};// Standardized execute function (new interface)
+base.updateProgress({state:"opening_file",phase:"processing",message:"Opening file with external app..."});_NativeBridge.default.file.openWithIntent(fileUrl,mimeType);},"intent file open");};// Standardized execute function (new interface)
 const execute=openFile;return{// Standardized interface
 data:base.data,loading:base.loading,progress:base.progress,error:base.error,isWeb:base.isWeb,isNative:base.isNative,execute,clear:base.clear,clearError:base.clearError,// Legacy aliases for backward compatibility
 isLoading:base.loading,processingState:base.progress?.phase||null,openFile,success:base.data?.success||null,reset:base.clear};};/**
  * React hook for file picker functionality
  * Manages file selection operations using standardized interface
  */exports.useIntent=useIntent;const useFilePicker=()=>{// Use standardized base hook
-const base=(0,_useBaseHook.useBaseHook)('useFilePicker');// Server-side rendering safety
+const base=(0,_useBaseHook.useBaseHook)("useFilePicker");// Server-side rendering safety
 if(typeof window==="undefined"){return{data:null,loading:false,progress:null,error:null,isWeb:true,isNative:false,execute:()=>{},clear:()=>{},clearError:()=>{},// Legacy aliases for backward compatibility
 selectedFile:null,pickFile:()=>{},isLoading:false,processingState:null,clearFile:()=>{}};}if(!window.WebBridge){throw new Error("WebBridge is not initialized. Call WebBridge.init() first.");}(0,_react.useEffect)(()=>{// Register callback handlers
-window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICKED,data=>{try{const fileData=typeof data==='string'?JSON.parse(data):data;console.log("📁 File picked:",fileData);base.setDataAndComplete(fileData);// Update progress with transport info if available
+window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICKED,data=>{try{const fileData=typeof data==="string"?JSON.parse(data):data;console.log("📁 File picked:",fileData);base.setDataAndComplete(fileData);// Update progress with transport info if available
 if(fileData.transport){base.updateProgress({transport:fileData.transport,bytesTotal:fileData.size||null});}}catch(parseError){console.error("📁 Error parsing file data:",parseError);base.handleNativeError("Error processing selected file");}});window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_ERROR,data=>{console.error("📁 File pick error:",data);base.handleNativeError(data);});window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_CANCELLED,data=>{console.log("📁 File pick cancelled:",data);base.setLoading(false);base.resetProgress();// Keep data as is when cancelled
 });// File picker state updates
-window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_STATE_UPDATE,data=>{try{const stateData=typeof data==='string'?JSON.parse(data):data;console.log("📁 File picker state:",stateData.state);// Map file picker states to standardized progress states
-const progressState=stateData.state==='opening'?'opening':stateData.state==='processing'?'processing':'starting';base.updateProgress({state:progressState,phase:stateData.state,message:`File picker: ${stateData.state}...`});if(stateData.state){base.setLoading(true);}}catch(parseError){console.error("📁 Error parsing state data:",parseError);}});return()=>{// Cleanup: unregister all handlers
-window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICKED);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_ERROR);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_CANCELLED);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_STATE_UPDATE);};},[base.setDataAndComplete,base.handleNativeError,base.setLoading,base.resetProgress,base.updateProgress]);const pickFile=(mimeType=null)=>{const finalMimeType=mimeType||"*/*";console.log("📁 Picking file with MIME type:",finalMimeType);base.executeOperation(()=>{_NativeBridge.default.file.pick(finalMimeType);},'file pick');};// Standardized execute function (new interface)
+window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_STATE_UPDATE,data=>{try{const stateData=typeof data==="string"?JSON.parse(data):data;console.log("📁 File picker state:",stateData.state);// Map file picker states to standardized progress states
+const progressState=stateData.state==="opening"?"opening":stateData.state==="processing"?"processing":"starting";base.updateProgress({state:progressState,phase:stateData.state,message:`File picker: ${stateData.state}...`});if(stateData.state){base.setLoading(true);}}catch(parseError){console.error("📁 Error parsing state data:",parseError);}});return()=>{// Cleanup: unregister all handlers
+window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICKED);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_ERROR);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_CANCELLED);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_STATE_UPDATE);};},[base.setDataAndComplete,base.handleNativeError,base.setLoading,base.resetProgress,base.updateProgress]);const pickFile=(mimeType=null)=>{const finalMimeType=mimeType||"*/*";console.log("📁 Picking file with MIME type:",finalMimeType);base.executeOperation(()=>{_NativeBridge.default.file.pick(finalMimeType);},"file pick");};// Standardized execute function (new interface)
 const execute=pickFile;return{// Standardized interface
 data:base.data,loading:base.loading,progress:base.progress,error:base.error,isWeb:base.isWeb,isNative:base.isNative,execute,clear:base.clear,clearError:base.clearError,// Legacy aliases for backward compatibility
 selectedFile:base.data,pickFile,isLoading:base.loading,processingState:base.progress?.phase||null,clearFile:base.clear};};/**
@@ -59,13 +59,13 @@ const handlePermissionStatus=data=>{window.WebBridge.unregister(_NativeInterface
 const handleHapticResponse=data=>{window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.HAPTIC_FEEDBACK);if(data===_NativeInterfaces.RESPONSE_STATUS.SUCCESS){resolve(data);}else{reject(new Error(`Haptic feedback failed: ${data}`));}};window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.HAPTIC_FEEDBACK,handleHapticResponse);_NativeBridge.default.haptic.feedback(feedbackType);console.log("📳 Haptic feedback requested:",feedbackType);}catch(error){reject(error);}});};/**
  * React hook for haptic feedback
  * Provides a function to trigger haptic feedback
- */exports.requestHapticFeedback=requestHapticFeedback;const useHapticFeedback=()=>{const base=(0,_useBaseHook.useBaseHook)('useHapticFeedback');const[capabilities,setCapabilities]=(0,_react.useState)({isSupported:false,availableTypes:['light','medium','heavy'],platform:'unknown'});// Haptic types
-const HAPTIC_TYPES={LIGHT:'light',MEDIUM:'medium',HEAVY:'heavy',SUCCESS:'success',WARNING:'warning',ERROR:'error',SELECTION:'selection',IMPACT:'impact'};(0,_react.useEffect)(()=>{// Initialize capabilities
-const userAgent=typeof navigator!=='undefined'?navigator.userAgent.toLowerCase():'';let platform='unknown';let isSupported=false;let availableTypes=[];if(base.isNative){isSupported=true;if(userAgent.includes('android')){platform='android';availableTypes=[HAPTIC_TYPES.LIGHT,HAPTIC_TYPES.MEDIUM,HAPTIC_TYPES.HEAVY];}else if(userAgent.includes('iphone')||userAgent.includes('ipad')){platform='ios';availableTypes=Object.values(HAPTIC_TYPES);}}else{platform='web';isSupported=typeof navigator!=='undefined'&&'vibrate'in navigator;if(isSupported){availableTypes=[HAPTIC_TYPES.LIGHT,HAPTIC_TYPES.MEDIUM,HAPTIC_TYPES.HEAVY];}}setCapabilities({isSupported,availableTypes,platform});},[base.isNative]);// Main execute function for haptic superhook
-const executeHaptic=(type='light',options={})=>{if(!capabilities.isSupported){const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.FEATURE_UNSUPPORTED,"Haptic feedback not supported",null,"Device does not support haptic feedback");base.handleNativeError(error);return;}return handleHapticTrigger(type,options);};// Haptic trigger handler
-const handleHapticTrigger=async(type,options={})=>{try{base.setLoading(true);base.updateProgress({state:'active',phase:'triggering',message:`Triggering ${type} haptic feedback...`});let success=false;if(base.isNative){// Use existing native implementation
+ */exports.requestHapticFeedback=requestHapticFeedback;const useHapticFeedback=()=>{const base=(0,_useBaseHook.useBaseHook)("useHapticFeedback");const[capabilities,setCapabilities]=(0,_react.useState)({isSupported:false,availableTypes:["light","medium","heavy"],platform:"unknown"});// Haptic types
+const HAPTIC_TYPES={LIGHT:"light",MEDIUM:"medium",HEAVY:"heavy",SUCCESS:"success",WARNING:"warning",ERROR:"error",SELECTION:"selection",IMPACT:"impact"};(0,_react.useEffect)(()=>{// Initialize capabilities
+const userAgent=typeof navigator!=="undefined"?navigator.userAgent.toLowerCase():"";let platform="unknown";let isSupported=false;let availableTypes=[];if(base.isNative){isSupported=true;if(userAgent.includes("android")){platform="android";availableTypes=[HAPTIC_TYPES.LIGHT,HAPTIC_TYPES.MEDIUM,HAPTIC_TYPES.HEAVY];}else if(userAgent.includes("iphone")||userAgent.includes("ipad")){platform="ios";availableTypes=Object.values(HAPTIC_TYPES);}}else{platform="web";isSupported=typeof navigator!=="undefined"&&"vibrate"in navigator;if(isSupported){availableTypes=[HAPTIC_TYPES.LIGHT,HAPTIC_TYPES.MEDIUM,HAPTIC_TYPES.HEAVY];}}setCapabilities({isSupported,availableTypes,platform});},[base.isNative]);// Main execute function for haptic superhook
+const executeHaptic=(type="light",options={})=>{if(!capabilities.isSupported){const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.FEATURE_UNSUPPORTED,"Haptic feedback not supported",null,"Device does not support haptic feedback");base.handleNativeError(error);return;}return handleHapticTrigger(type,options);};// Haptic trigger handler
+const handleHapticTrigger=async(type,options={})=>{try{base.setLoading(true);base.updateProgress({state:"active",phase:"triggering",message:`Triggering ${type} haptic feedback...`});let success=false;if(base.isNative){// Use existing native implementation
 success=await requestHapticFeedback(type);}else{// Web fallback
-success=handleWebHaptic(type,options);}const hapticData={lastType:type,lastOptions:options,timestamp:new Date().toISOString(),success:success,capabilities:capabilities,lastOperation:'trigger',operationSuccess:success};base.setDataAndComplete(hapticData);return success;}catch(error){console.error("📳 Haptic feedback failed:",error);base.handleNativeError(error);return false;}};// Web haptic fallback
+success=handleWebHaptic(type,options);}const hapticData={lastType:type,lastOptions:options,timestamp:new Date().toISOString(),success:success,capabilities:capabilities,lastOperation:"trigger",operationSuccess:success};base.setDataAndComplete(hapticData);return success;}catch(error){console.error("📳 Haptic feedback failed:",error);base.handleNativeError(error);return false;}};// Web haptic fallback
 const handleWebHaptic=(type,options={})=>{if(!navigator.vibrate){return false;}const vibrationPatterns={[HAPTIC_TYPES.LIGHT]:[50],[HAPTIC_TYPES.MEDIUM]:[100],[HAPTIC_TYPES.HEAVY]:[200],[HAPTIC_TYPES.SUCCESS]:[100,50,100],[HAPTIC_TYPES.WARNING]:[200,100,200],[HAPTIC_TYPES.ERROR]:[300,100,300,100,300],[HAPTIC_TYPES.SELECTION]:[25],[HAPTIC_TYPES.IMPACT]:[150]};const pattern=vibrationPatterns[type]||[100];navigator.vibrate(pattern);return true;};// Return standardized superhook interface
 return{// Standard interface (from useBaseHook)
 data:base.data,loading:base.loading,progress:base.progress,error:base.error,isWeb:base.isWeb,isNative:base.isNative,clear:base.clear,clearError:base.clearError,// Main execute function

package/dist/native/bridge/standardizedHooks.js

@@ -2,26 +2,26 @@
  * Standardized Camera Superhook
  * Comprehensive camera functionality with integrated permission management
  * Follows standardized interface with execute as primary function
- * 
+ *
  * @param {Object} options - Configuration options
  * @returns {Object} Standardized camera superhook interface
- */const useCamera=(options={})=>{const base=(0,_useBaseHook.useBaseHook)('useCamera',options);const[permission,setPermission]=(0,_react.useState)({status:'not_determined',canRequest:true,lastChecked:null});// Camera operations
-const CAMERA_OPERATIONS={TAKE_PHOTO:'takePhoto',REQUEST_PERMISSION:'requestPermission',CHECK_PERMISSION:'checkPermission'};// Camera-specific progress phases
-const CAMERA_PHASES={REQUESTING_PERMISSION:'requesting_permission',CHECKING_PERMISSION:'checking_permission',OPENING_CAMERA:'opening_camera',CAPTURING:'capturing',PROCESSING:'processing',COMPLETE:'complete'};(0,_react.useEffect)(()=>{// Server-side rendering safety
+ */const useCamera=(options={})=>{const base=(0,_useBaseHook.useBaseHook)("useCamera",options);const[permission,setPermission]=(0,_react.useState)({status:"not_determined",canRequest:true,lastChecked:null});// Camera operations
+const CAMERA_OPERATIONS={TAKE_PHOTO:"takePhoto",REQUEST_PERMISSION:"requestPermission",CHECK_PERMISSION:"checkPermission"};// Camera-specific progress phases
+const CAMERA_PHASES={REQUESTING_PERMISSION:"requesting_permission",CHECKING_PERMISSION:"checking_permission",OPENING_CAMERA:"opening_camera",CAPTURING:"capturing",PROCESSING:"processing",COMPLETE:"complete"};(0,_react.useEffect)(()=>{// Server-side rendering safety
 if(typeof window==="undefined")return;if(!window.WebBridge){console.warn("WebBridge not initialized. Camera functionality unavailable.");return;}// Camera capture success handler
-const handleCameraCapture=data=>{try{const result=typeof data==='string'?JSON.parse(data):data;base.updateProgress({phase:CAMERA_PHASES.PROCESSING,message:'Processing captured photo...'});// Handle new tri-transport format or legacy format
+const handleCameraCapture=data=>{try{const result=typeof data==="string"?JSON.parse(data):data;base.updateProgress({phase:CAMERA_PHASES.PROCESSING,message:"Processing captured photo..."});// Handle new tri-transport format or legacy format
 const photoData=result.fileSrc?{// New tri-transport format
 fileSrc:result.fileSrc,fileName:result.fileName,size:result.size,mimeType:result.mimeType,transport:result.transport,source:result.source,filePath:result.filePath}:{// Legacy format (fallback)
-fileSrc:result.imageUrl,fileName:result.fileName||'camera_photo.jpg',size:result.size||0,mimeType:result.mimeType||'image/jpeg',transport:'LEGACY',source:'camera',filePath:result.filePath||null};// Create comprehensive data object with photo and permission info
+fileSrc:result.imageUrl,fileName:result.fileName||"camera_photo.jpg",size:result.size||0,mimeType:result.mimeType||"image/jpeg",transport:"LEGACY",source:"camera",filePath:result.filePath||null};// Create comprehensive data object with photo and permission info
 const cameraData={...photoData,permission:permission,lastOperation:CAMERA_OPERATIONS.TAKE_PHOTO,operationSuccess:true,timestamp:new Date().toISOString()};base.setDataAndComplete(cameraData);console.log("📷 Photo captured successfully via transport:",photoData.transport);}catch(parseError){console.error("📷 Error parsing camera capture data:",parseError);const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.INTERNAL_ERROR,"Failed to process captured photo",parseError);base.handleNativeError(error);}};// Camera permission status handler
-const handlePermissionStatus=data=>{const permissionStatus=typeof data==='string'?data:data.status||data;const newPermission={status:permissionStatus.toLowerCase(),canRequest:permissionStatus!=='permanently_denied',lastChecked:new Date().toISOString()};setPermission(newPermission);console.log("📷 Camera permission status:",newPermission);// Update data with permission info
-const permissionData={permission:newPermission,lastOperation:CAMERA_OPERATIONS.REQUEST_PERMISSION,operationSuccess:permissionStatus==='GRANTED',timestamp:new Date().toISOString()};if(permissionStatus==='GRANTED'){base.updateProgress({phase:CAMERA_PHASES.OPENING_CAMERA,message:'Camera permission granted, ready to capture...'});base.setDataAndComplete(permissionData);}else if(permissionStatus==='DENIED'){const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.PERMISSION_DENIED,"Camera permission denied",null,"Camera permission is required to take photos");base.handleNativeError(error);}};// Camera error handler
+const handlePermissionStatus=data=>{const permissionStatus=typeof data==="string"?data:data.status||data;const newPermission={status:permissionStatus.toLowerCase(),canRequest:permissionStatus!=="permanently_denied",lastChecked:new Date().toISOString()};setPermission(newPermission);console.log("📷 Camera permission status:",newPermission);// Update data with permission info
+const permissionData={permission:newPermission,lastOperation:CAMERA_OPERATIONS.REQUEST_PERMISSION,operationSuccess:permissionStatus==="GRANTED",timestamp:new Date().toISOString()};if(permissionStatus==="GRANTED"){base.updateProgress({phase:CAMERA_PHASES.OPENING_CAMERA,message:"Camera permission granted, ready to capture..."});base.setDataAndComplete(permissionData);}else if(permissionStatus==="DENIED"){const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.PERMISSION_DENIED,"Camera permission denied",null,"Camera permission is required to take photos");base.handleNativeError(error);}};// Camera error handler
 const handleCameraError=data=>{console.error("📷 Camera error:",data);base.handleNativeError(data);};// Register event listeners
 window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_CAMERA_CAPTURE,handleCameraCapture);window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.CAMERA_PERMISSION_STATUS,handlePermissionStatus);window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_CAMERA_ERROR,handleCameraError);// Cleanup function
 return()=>{window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_CAMERA_CAPTURE);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.CAMERA_PERMISSION_STATUS);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_CAMERA_ERROR);};},[base]);// Main execute function for camera superhook
-const executeCamera=(operation,...args)=>{if(base.isWeb){console.warn(`Camera ${operation} requires web fallback implementation (isWeb: true)`);return;}switch(operation){case CAMERA_OPERATIONS.TAKE_PHOTO:return handleTakePhoto(args[0]||{});case CAMERA_OPERATIONS.REQUEST_PERMISSION:return handleRequestPermission();case CAMERA_OPERATIONS.CHECK_PERMISSION:return handleCheckPermission();default:const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.INVALID_PARAMETERS,`Unknown camera operation: ${operation}`,null,`Valid operations: ${Object.values(CAMERA_OPERATIONS).join(', ')}`);base.handleNativeError(error);}};// Camera operation handlers
-const handleTakePhoto=(cameraOptions={})=>{base.executeOperation(()=>{base.updateProgress({phase:CAMERA_PHASES.REQUESTING_PERMISSION,message:'Requesting camera permission...'});_NativeBridge.default.camera.open(cameraOptions);console.log("📷 Camera open requested with options:",cameraOptions);},'photo capture');};const handleRequestPermission=()=>{base.executeOperation(()=>{base.updateProgress({phase:CAMERA_PHASES.REQUESTING_PERMISSION,message:'Requesting camera permission...'});if(_NativeBridge.default.camera.requestPermission){_NativeBridge.default.camera.requestPermission();}else{// Fallback method
-_NativeBridge.default.camera.checkPermission();}console.log("📷 Camera permission requested");},'permission request');};const handleCheckPermission=()=>{base.executeOperation(()=>{base.updateProgress({phase:CAMERA_PHASES.CHECKING_PERMISSION,message:'Checking camera permission...'});_NativeBridge.default.camera.checkPermission();console.log("📷 Camera permission check requested");},'permission check');};// Return standardized superhook interface
+const executeCamera=(operation,...args)=>{if(base.isWeb){console.warn(`Camera ${operation} requires web fallback implementation (isWeb: true)`);return;}switch(operation){case CAMERA_OPERATIONS.TAKE_PHOTO:return handleTakePhoto(args[0]||{});case CAMERA_OPERATIONS.REQUEST_PERMISSION:return handleRequestPermission();case CAMERA_OPERATIONS.CHECK_PERMISSION:return handleCheckPermission();default:const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.INVALID_PARAMETERS,`Unknown camera operation: ${operation}`,null,`Valid operations: ${Object.values(CAMERA_OPERATIONS).join(", ")}`);base.handleNativeError(error);}};// Camera operation handlers
+const handleTakePhoto=(cameraOptions={})=>{base.executeOperation(()=>{base.updateProgress({phase:CAMERA_PHASES.REQUESTING_PERMISSION,message:"Requesting camera permission..."});_NativeBridge.default.camera.open(cameraOptions);console.log("📷 Camera open requested with options:",cameraOptions);},"photo capture");};const handleRequestPermission=()=>{base.executeOperation(()=>{base.updateProgress({phase:CAMERA_PHASES.REQUESTING_PERMISSION,message:"Requesting camera permission..."});if(_NativeBridge.default.camera.requestPermission){_NativeBridge.default.camera.requestPermission();}else{// Fallback method
+_NativeBridge.default.camera.checkPermission();}console.log("📷 Camera permission requested");},"permission request");};const handleCheckPermission=()=>{base.executeOperation(()=>{base.updateProgress({phase:CAMERA_PHASES.CHECKING_PERMISSION,message:"Checking camera permission..."});_NativeBridge.default.camera.checkPermission();console.log("📷 Camera permission check requested");},"permission check");};// Return standardized superhook interface
 return{// Standard interface (from useBaseHook)
 data:base.data,loading:base.loading,progress:base.progress,error:base.error,isWeb:base.isWeb,isNative:base.isNative,clear:base.clear,clearError:base.clearError,// Main execute function
 execute:executeCamera,// Semantic aliases for execute
@@ -30,20 +30,20 @@ permission:permission,// Legacy compatibility
 photo:base.data,clearPhoto:base.clear};};/**
  * Standardized File Picker Hook
  * Provides consistent interface with error standardization and environment detection
- * 
+ *
  * @param {Object} options - Configuration options
  * @returns {Object} Standardized file picker interface
- */exports.useCamera=useCamera;const useFilePicker=(options={})=>{const base=(0,_useBaseHook.useBaseHook)('useFilePicker',options);// File picker specific progress phases
-const FILE_PICKER_PHASES={OPENING:'opening',PROCESSING:'processing',ROUTING:'routing',COMPLETE:'complete'};(0,_react.useEffect)(()=>{// Server-side rendering safety
+ */exports.useCamera=useCamera;const useFilePicker=(options={})=>{const base=(0,_useBaseHook.useBaseHook)("useFilePicker",options);// File picker specific progress phases
+const FILE_PICKER_PHASES={OPENING:"opening",PROCESSING:"processing",ROUTING:"routing",COMPLETE:"complete"};(0,_react.useEffect)(()=>{// Server-side rendering safety
 if(typeof window==="undefined")return;if(!window.WebBridge){console.warn("WebBridge not initialized. File picker functionality unavailable.");return;}// File picked success handler
-const handleFilePicked=data=>{try{const result=typeof data==='string'?JSON.parse(data):data;console.log("📁 File picked result:",result);base.updateProgress({phase:FILE_PICKER_PHASES.PROCESSING,message:'Processing selected file...'});// Handle tri-transport format
+const handleFilePicked=data=>{try{const result=typeof data==="string"?JSON.parse(data):data;console.log("📁 File picked result:",result);base.updateProgress({phase:FILE_PICKER_PHASES.PROCESSING,message:"Processing selected file..."});// Handle tri-transport format
 const fileData={fileSrc:result.fileSrc,fileName:result.fileName,size:result.size,mimeType:result.mimeType,transport:result.transport,filePath:result.filePath};base.setDataAndComplete(fileData);console.log("📁 File processed successfully via transport:",fileData.transport);}catch(parseError){console.error("📁 Error parsing file picker data:",parseError);const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.INTERNAL_ERROR,"Failed to process selected file",parseError);base.handleNativeError(error);}};// File pick error handler
 const handleFilePickError=data=>{console.error("📁 File pick error:",data);base.handleNativeError(data);};// File pick cancelled handler
 const handleFilePickCancelled=data=>{console.log("📁 File pick cancelled:",data);const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.OPERATION_CANCELLED,"File selection was cancelled",data);base.handleNativeError(error);};// File picker state updates
-const handleFilePickStateUpdate=data=>{try{const stateData=typeof data==='string'?JSON.parse(data):data;console.log("📁 File picker state:",stateData.state);let phase=FILE_PICKER_PHASES.PROCESSING;let message='Processing...';switch(stateData.state){case'opening':phase=FILE_PICKER_PHASES.OPENING;message='Opening file picker...';break;case'processing':phase=FILE_PICKER_PHASES.PROCESSING;message='Processing selected file...';break;case'routing':phase=FILE_PICKER_PHASES.ROUTING;message='Determining transport method...';break;default:message=stateData.state;}base.updateProgress({phase,message});}catch(parseError){console.error("📁 Error parsing file picker state:",parseError);}};// Register event listeners
+const handleFilePickStateUpdate=data=>{try{const stateData=typeof data==="string"?JSON.parse(data):data;console.log("📁 File picker state:",stateData.state);let phase=FILE_PICKER_PHASES.PROCESSING;let message="Processing...";switch(stateData.state){case"opening":phase=FILE_PICKER_PHASES.OPENING;message="Opening file picker...";break;case"processing":phase=FILE_PICKER_PHASES.PROCESSING;message="Processing selected file...";break;case"routing":phase=FILE_PICKER_PHASES.ROUTING;message="Determining transport method...";break;default:message=stateData.state;}base.updateProgress({phase,message});}catch(parseError){console.error("📁 Error parsing file picker state:",parseError);}};// Register event listeners
 window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICKED,handleFilePicked);window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_ERROR,handleFilePickError);window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_CANCELLED,handleFilePickCancelled);window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_STATE_UPDATE,handleFilePickStateUpdate);// Cleanup function
 return()=>{window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICKED);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_ERROR);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_CANCELLED);window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_FILE_PICK_STATE_UPDATE);};},[base]);// Pick file function
-const pickFile=(mimeType=null)=>{base.executeOperation(()=>{const finalMimeType=mimeType||"*/*";base.updateProgress({phase:FILE_PICKER_PHASES.OPENING,message:`Opening file picker${mimeType?` for ${mimeType}`:''}...`});_NativeBridge.default.file.pick(finalMimeType);console.log("📁 File picker opened with MIME type:",finalMimeType);},'file selection');};// Return standardized interface
+const pickFile=(mimeType=null)=>{base.executeOperation(()=>{const finalMimeType=mimeType||"*/*";base.updateProgress({phase:FILE_PICKER_PHASES.OPENING,message:`Opening file picker${mimeType?` for ${mimeType}`:""}...`});_NativeBridge.default.file.pick(finalMimeType);console.log("📁 File picker opened with MIME type:",finalMimeType);},"file selection");};// Return standardized interface
 return{// Standard interface
 data:base.data,loading:base.loading,progress:base.progress,error:base.error,isWeb:base.isWeb,isNative:base.isNative,// Actions
 execute:pickFile,// Standard execute function
@@ -56,21 +56,21 @@ clearFile:base.clear// Legacy alias
 };};/**
  * Standardized Intent Hook
  * Provides consistent interface with error standardization and environment detection
- * 
+ *
  * @param {Object} options - Configuration options
  * @returns {Object} Standardized intent interface
- */exports.useFilePicker=useFilePicker;const useIntent=(options={})=>{const base=(0,_useBaseHook.useBaseHook)('useIntent',options);// Intent specific progress phases
-const INTENT_PHASES={PREPARING:'preparing',DOWNLOADING:'downloading',OPENING:'opening',COMPLETE:'complete'};(0,_react.useEffect)(()=>{// Server-side rendering safety
+ */exports.useFilePicker=useFilePicker;const useIntent=(options={})=>{const base=(0,_useBaseHook.useBaseHook)("useIntent",options);// Intent specific progress phases
+const INTENT_PHASES={PREPARING:"preparing",DOWNLOADING:"downloading",OPENING:"opening",COMPLETE:"complete"};(0,_react.useEffect)(()=>{// Server-side rendering safety
 if(typeof window==="undefined")return;if(!window.WebBridge){console.warn("WebBridge not initialized. Intent functionality unavailable.");return;}// Intent success handler
-const handleIntentSuccess=data=>{try{const result=typeof data==='string'?JSON.parse(data):data;console.log("🔗 Intent success result:",result);const intentData={url:result.url,mimeType:result.mimeType,success:result.success||true,message:result.message||'File opened successfully'};base.setDataAndComplete(intentData);console.log("🔗 Intent completed successfully");}catch(parseError){console.error("🔗 Error parsing intent result:",parseError);const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.INTERNAL_ERROR,"Failed to process intent result",parseError);base.handleNativeError(error);}};// Intent error handler
+const handleIntentSuccess=data=>{try{const result=typeof data==="string"?JSON.parse(data):data;console.log("🔗 Intent success result:",result);const intentData={url:result.url,mimeType:result.mimeType,success:result.success||true,message:result.message||"File opened successfully"};base.setDataAndComplete(intentData);console.log("🔗 Intent completed successfully");}catch(parseError){console.error("🔗 Error parsing intent result:",parseError);const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.INTERNAL_ERROR,"Failed to process intent result",parseError);base.handleNativeError(error);}};// Intent error handler
 const handleIntentError=data=>{console.error("🔗 Intent error:",data);base.handleNativeError(data);};// Intent state updates (if available)
-const handleIntentStateUpdate=data=>{try{const stateData=typeof data==='string'?JSON.parse(data):data;console.log("🔗 Intent state:",stateData.state);let phase=INTENT_PHASES.PREPARING;let message='Processing...';switch(stateData.state){case'preparing':phase=INTENT_PHASES.PREPARING;message='Preparing to open file...';break;case'downloading':phase=INTENT_PHASES.DOWNLOADING;message='Downloading file...';break;case'opening':phase=INTENT_PHASES.OPENING;message='Opening with external app...';break;default:message=stateData.state;}base.updateProgress({phase,message,percentage:stateData.percentage||null});}catch(parseError){console.error("🔗 Error parsing intent state:",parseError);}};// Register event listeners (some callbacks might not exist in legacy intent)
-window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_SUCCESS||'ON_INTENT_SUCCESS',handleIntentSuccess);window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_ERROR||'ON_INTENT_ERROR',handleIntentError);// Optional state updates (might not be implemented in current intent system)
+const handleIntentStateUpdate=data=>{try{const stateData=typeof data==="string"?JSON.parse(data):data;console.log("🔗 Intent state:",stateData.state);let phase=INTENT_PHASES.PREPARING;let message="Processing...";switch(stateData.state){case"preparing":phase=INTENT_PHASES.PREPARING;message="Preparing to open file...";break;case"downloading":phase=INTENT_PHASES.DOWNLOADING;message="Downloading file...";break;case"opening":phase=INTENT_PHASES.OPENING;message="Opening with external app...";break;default:message=stateData.state;}base.updateProgress({phase,message,percentage:stateData.percentage||null});}catch(parseError){console.error("🔗 Error parsing intent state:",parseError);}};// Register event listeners (some callbacks might not exist in legacy intent)
+window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_SUCCESS||"ON_INTENT_SUCCESS",handleIntentSuccess);window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_ERROR||"ON_INTENT_ERROR",handleIntentError);// Optional state updates (might not be implemented in current intent system)
 if(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_STATE_UPDATE){window.WebBridge.register(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_STATE_UPDATE,handleIntentStateUpdate);}// Cleanup function
-return()=>{window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_SUCCESS||'ON_INTENT_SUCCESS');window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_ERROR||'ON_INTENT_ERROR');if(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_STATE_UPDATE){window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_STATE_UPDATE);}};},[base]);// Open file function
+return()=>{window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_SUCCESS||"ON_INTENT_SUCCESS");window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_ERROR||"ON_INTENT_ERROR");if(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_STATE_UPDATE){window.WebBridge.unregister(_NativeInterfaces.NATIVE_CALLBACKS.ON_INTENT_STATE_UPDATE);}};},[base]);// Open file function
 const openFile=(url,mimeType=null)=>{if(!url){const error=(0,_errors.createStandardError)(_errors.ERROR_CODES.INVALID_PARAMETERS,"URL is required for opening files",null,"Please provide a valid URL to open");base.handleNativeError(error);return;}base.executeOperation(()=>{const finalMimeType=mimeType||"*/*";base.updateProgress({phase:INTENT_PHASES.PREPARING,message:`Preparing to open ${url}...`});// Check if intent system has specific methods
 if(_NativeBridge.default.intent&&_NativeBridge.default.intent.openFile){_NativeBridge.default.intent.openFile(url,finalMimeType);}else{// Fallback to generic method if available
-_NativeBridge.default.openFile(url,finalMimeType);}console.log("🔗 Intent to open file:",url,"with MIME type:",finalMimeType);},'file opening');};// Return standardized interface
+_NativeBridge.default.openFile(url,finalMimeType);}console.log("🔗 Intent to open file:",url,"with MIME type:",finalMimeType);},"file opening");};// Return standardized interface
 return{// Standard interface
 data:base.data,loading:base.loading,progress:base.progress,error:base.error,isWeb:base.isWeb,isNative:base.isNative,// Actions
 execute:openFile,// Standard execute function

package/dist/native/bridge/useBaseHook.js

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.useEnvironmentInfo=exports.useBaseHook=exports.PROGRESS_STATES=void 0;var _react=require("react");var _NativeBridge=_interopRequireDefault(require("./utils/NativeBridge.js"));var _errors=require("./errors");function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e};}/**
  * Base hook utility that provides standardized interface for all Catalyst hooks
  * Handles environment detection, error standardization, and common state management
- * 
+ *
  * @param {string} hookName - Name of the hook for debugging purposes
  * @param {Object} options - Configuration options
  * @returns {Object} Base hook interface with common functionality
@@ -9,7 +9,7 @@
 const isNative=(0,_react.useCallback)(()=>{// Server-side rendering safety
 if(typeof window==="undefined")return false;// Check for WebBridge and verify it's functional
 return!!(window.WebBridge&&_NativeBridge.default.isAvailable());},[]);const isWeb=(0,_react.useCallback)(()=>{return!isNative();},[isNative]);// Common state management
-const[data,setData]=(0,_react.useState)(null);const[loading,setLoading]=(0,_react.useState)(false);const[error,setError]=(0,_react.useState)(null);const[progress,setProgress]=(0,_react.useState)({state:'idle',// 'idle' | 'opening' | 'processing' | 'routing' | 'complete' | 'error'
+const[data,setData]=(0,_react.useState)(null);const[loading,setLoading]=(0,_react.useState)(false);const[error,setError]=(0,_react.useState)(null);const[progress,setProgress]=(0,_react.useState)({state:"idle",// 'idle' | 'opening' | 'processing' | 'routing' | 'complete' | 'error'
 percentage:null,// 0-100 or null
 message:null,// Human readable message or null
 phase:null,// Operation specific phase or null
@@ -17,11 +17,11 @@ transport:null,// Transport method being used
 bytesLoaded:null,// Bytes processed
 bytesTotal:null// Total bytes
 });// Progress management utilities
-const updateProgress=(0,_react.useCallback)(updates=>{setProgress(prev=>({...prev,...updates}));},[]);const resetProgress=(0,_react.useCallback)(()=>{setProgress({state:'idle',percentage:null,message:null,phase:null,transport:null,bytesLoaded:null,bytesTotal:null});},[]);const startProgress=(0,_react.useCallback)((phase=null,message=null)=>{updateProgress({state:'active',phase,message,percentage:null});},[updateProgress]);const completeProgress=(0,_react.useCallback)(()=>{updateProgress({state:'complete',percentage:100});},[updateProgress]);const errorProgress=(0,_react.useCallback)(()=>{updateProgress({state:'error'});},[updateProgress]);// Error handling utilities
+const updateProgress=(0,_react.useCallback)(updates=>{setProgress(prev=>({...prev,...updates}));},[]);const resetProgress=(0,_react.useCallback)(()=>{setProgress({state:"idle",percentage:null,message:null,phase:null,transport:null,bytesLoaded:null,bytesTotal:null});},[]);const startProgress=(0,_react.useCallback)((phase=null,message=null)=>{updateProgress({state:"active",phase,message,percentage:null});},[updateProgress]);const completeProgress=(0,_react.useCallback)(()=>{updateProgress({state:"complete",percentage:100});},[updateProgress]);const errorProgress=(0,_react.useCallback)(()=>{updateProgress({state:"error"});},[updateProgress]);// Error handling utilities
 const handleNativeError=(0,_react.useCallback)(nativeError=>{const standardError=(0,_errors.translateError)(nativeError);setError(standardError);setLoading(false);errorProgress();// Development logging
-if((0,_errors.isDevelopment)()){console.group(`🚨 ${hookName} Error`);console.log('Standard Error:',standardError);console.log('Native Error:',nativeError);console.groupEnd();}return standardError;},[hookName,errorProgress]);const clearError=(0,_react.useCallback)(()=>{setError(null);if(progress.state==='error'){resetProgress();}},[progress.state,resetProgress]);// Data management utilities
+if((0,_errors.isDevelopment)()){console.group(`🚨 ${hookName} Error`);console.log("Standard Error:",standardError);console.log("Native Error:",nativeError);console.groupEnd();}return standardError;},[hookName,errorProgress]);const clearError=(0,_react.useCallback)(()=>{setError(null);if(progress.state==="error"){resetProgress();}},[progress.state,resetProgress]);// Data management utilities
 const setDataAndComplete=(0,_react.useCallback)(newData=>{setData(newData);setLoading(false);completeProgress();setError(null);if((0,_errors.isDevelopment)()){console.log(`✅ ${hookName} Success:`,newData);}},[hookName,completeProgress]);const clear=(0,_react.useCallback)(()=>{setData(null);setError(null);resetProgress();if((0,_errors.isDevelopment)()){console.log(`🗑️ ${hookName} Cleared`);}},[hookName,resetProgress]);// Operation wrapper that handles common patterns
-const executeOperation=(0,_react.useCallback)((operationCallback,operationName='operation')=>{try{if(isWeb()){console.warn(`${hookName} requires web fallback implementation (isWeb: true)`);return;}if(!_NativeBridge.default.isAvailable()){throw new Error("Native bridge not available");}setLoading(true);setError(null);startProgress('starting',`Starting ${operationName}...`);if((0,_errors.isDevelopment)()){console.log(`🚀 ${hookName} ${operationName} started`);}// Execute the actual operation
+const executeOperation=(0,_react.useCallback)((operationCallback,operationName="operation")=>{try{if(isWeb()){console.warn(`${hookName} requires web fallback implementation (isWeb: true)`);return;}if(!_NativeBridge.default.isAvailable()){throw new Error("Native bridge not available");}setLoading(true);setError(null);startProgress("starting",`Starting ${operationName}...`);if((0,_errors.isDevelopment)()){console.log(`🚀 ${hookName} ${operationName} started`);}// Execute the actual operation
 operationCallback();}catch(err){handleNativeError(err);console.error(`❌ ${hookName} ${operationName} failed:`,err);}},[hookName,isWeb,startProgress,handleNativeError]);// Environment flags (computed values, not functions)
 const environmentFlags={isWeb:isWeb(),isNative:isNative()};// Return standardized interface
 return{// Data state
@@ -32,13 +32,13 @@ error,// Environment detection
 clear,clearError,// Internal utilities for specific hooks
 setData,setLoading,setError,setProgress,updateProgress,resetProgress,startProgress,completeProgress,errorProgress,setDataAndComplete,handleNativeError,executeOperation};};/**
  * Hook for development debugging and testing
- * @param {string} hookName 
+ * @param {string} hookName
  * @returns {Object} Environment information and utilities
- */exports.useBaseHook=useBaseHook;const useEnvironmentInfo=hookName=>{const isNativeAvailable=()=>{if(typeof window==="undefined")return false;return!!(window.WebBridge&&_NativeBridge.default.isAvailable());};const getEnvironmentDetails=()=>{const details={hasWindow:typeof window!=="undefined",hasWebBridge:typeof window!=="undefined"&&!!window.WebBridge,nativeBridgeAvailable:false,userAgent:typeof navigator!=="undefined"?navigator.userAgent:'SSR',timestamp:new Date().toISOString()};if(details.hasWebBridge){details.nativeBridgeAvailable=_NativeBridge.default.isAvailable();}return details;};if((0,_errors.isDevelopment)()){console.log(`🔍 ${hookName} Environment:`,getEnvironmentDetails());}return{isNative:isNativeAvailable(),isWeb:!isNativeAvailable(),environmentDetails:getEnvironmentDetails()};};/**
+ */exports.useBaseHook=useBaseHook;const useEnvironmentInfo=hookName=>{const isNativeAvailable=()=>{if(typeof window==="undefined")return false;return!!(window.WebBridge&&_NativeBridge.default.isAvailable());};const getEnvironmentDetails=()=>{const details={hasWindow:typeof window!=="undefined",hasWebBridge:typeof window!=="undefined"&&!!window.WebBridge,nativeBridgeAvailable:false,userAgent:typeof navigator!=="undefined"?navigator.userAgent:"SSR",timestamp:new Date().toISOString()};if(details.hasWebBridge){details.nativeBridgeAvailable=_NativeBridge.default.isAvailable();}return details;};if((0,_errors.isDevelopment)()){console.log(`🔍 ${hookName} Environment:`,getEnvironmentDetails());}return{isNative:isNativeAvailable(),isWeb:!isNativeAvailable(),environmentDetails:getEnvironmentDetails()};};/**
  * Progress state constants for consistency across hooks
  */exports.useEnvironmentInfo=useEnvironmentInfo;const PROGRESS_STATES=exports.PROGRESS_STATES={// Common states
-IDLE:'idle',STARTING:'starting',COMPLETE:'complete',ERROR:'error',// File Picker states
-OPENING:'opening',PROCESSING:'processing',ROUTING:'routing',// Camera states
-REQUESTING:'requesting',CAPTURING:'capturing',// Intent states
-DOWNLOADING:'downloading',OPENING_FILE:'opening_file',// Server states
-CONNECTING:'connecting',UPLOADING:'uploading',SERVING:'serving'};
+IDLE:"idle",STARTING:"starting",COMPLETE:"complete",ERROR:"error",// File Picker states
+OPENING:"opening",PROCESSING:"processing",ROUTING:"routing",// Camera states
+REQUESTING:"requesting",CAPTURING:"capturing",// Intent states
+DOWNLOADING:"downloading",OPENING_FILE:"opening_file",// Server states
+CONNECTING:"connecting",UPLOADING:"uploading",SERVING:"serving"};

package/dist/native/bridge/utils/NativeBridge.js

@@ -2,30 +2,30 @@
  * NativeBridge Utility
  * Handles communication from Web to Native platforms
  * Supports both Android (window.NativeBridge) and iOS (webkit.messageHandlers)
- */class NativeBridgeUtil{constructor(){this.isAndroid=this._detectAndroid();this.isIOS=this._detectIOS();this.isNativeEnvironment=this.isAndroid||this.isIOS;if(typeof window!=='undefined'){this._logEnvironmentInfo();}}/**
+ */class NativeBridgeUtil{constructor(){this.isAndroid=this._detectAndroid();this.isIOS=this._detectIOS();this.isNativeEnvironment=this.isAndroid||this.isIOS;if(typeof window!=="undefined"){this._logEnvironmentInfo();}}/**
      * Detect if running on Android WebView
-     */_detectAndroid(){if(typeof window==='undefined')return false;return!!(window.NativeBridge&&typeof window.NativeBridge==='object');}/**
+     */_detectAndroid(){if(typeof window==="undefined")return false;return!!(window.NativeBridge&&typeof window.NativeBridge==="object");}/**
      * Detect if running on iOS WebView
-     */_detectIOS(){if(typeof window==='undefined')return false;return!!window.webkit?.messageHandlers?.NativeBridge;}/**
+     */_detectIOS(){if(typeof window==="undefined")return false;return!!window.webkit?.messageHandlers?.NativeBridge;}/**
      * Log environment detection info for debugging
-     */_logEnvironmentInfo(){console.log('🌉 NativeBridge Environment Detection:',{isAndroid:this.isAndroid,isIOS:this.isIOS,isNativeEnvironment:this.isNativeEnvironment,hasAndroidBridge:!!window.NativeBridge,hasIOSBridge:!!window.webkit?.messageHandlers?.NativeBridge});}/**
+     */_logEnvironmentInfo(){console.log("🌉 NativeBridge Environment Detection:",{isAndroid:this.isAndroid,isIOS:this.isIOS,isNativeEnvironment:this.isNativeEnvironment,hasAndroidBridge:!!window.NativeBridge,hasIOSBridge:!!window.webkit?.messageHandlers?.NativeBridge});}/**
      * Validate command before execution
-     */_validateCommand(command){if(!command){throw new Error('Command is required');}if(!(0,_NativeInterfaces.isValidCommand)(command)){throw new Error(`Invalid command: ${command}. Available commands: ${Object.values(_NativeInterfaces.NATIVE_COMMANDS).join(', ')}`);}if(!this.isNativeEnvironment){throw new Error('Native bridge not available. Ensure you are running in a native WebView environment.');}}/**
+     */_validateCommand(command){if(!command){throw new Error("Command is required");}if(!(0,_NativeInterfaces.isValidCommand)(command)){throw new Error(`Invalid command: ${command}. Available commands: ${Object.values(_NativeInterfaces.NATIVE_COMMANDS).join(", ")}`);}if(!this.isNativeEnvironment){throw new Error("Native bridge not available. Ensure you are running in a native WebView environment.");}}/**
      * Execute command on Android platform
-     */_executeAndroidCommand(command,data){try{if(typeof window.NativeBridge[command]==='function'){console.log(`🌉 Calling Android method '${command}'`,data?{data}:'(no data)');// Always pass data parameter to match Kotlin method signatures
+     */_executeAndroidCommand(command,data){try{if(typeof window.NativeBridge[command]==="function"){console.log(`🌉 Calling Android method '${command}'`,data?{data}:"(no data)");// Always pass data parameter to match Kotlin method signatures
 window.NativeBridge[command](data);return true;}else{throw new Error(`Android bridge method '${command}' not found`);}}catch(error){console.error(`Error executing Android command '${command}':`,error);throw error;}}/**
      * Execute command on iOS platform
      */_executeIOSCommand(command,data){try{// For iOS, we always send a message object
 const message={command:command,data:data// This can be null/undefined, iOS bridge should handle it
-};console.log(`🌉 Calling iOS method '${command}'`,data?{data}:'(no data)');window.webkit.messageHandlers.NativeBridge.postMessage(message);return true;}catch(error){console.error(`Error executing iOS command '${command}':`,error);throw error;}}/**
+};console.log(`🌉 Calling iOS method '${command}'`,data?{data}:"(no data)");window.webkit.messageHandlers.NativeBridge.postMessage(message);return true;}catch(error){console.error(`Error executing iOS command '${command}':`,error);throw error;}}/**
      * Main method to call native commands
      * @param {string} command - The command to execute (from NATIVE_COMMANDS)
      * @param {any} data - Optional data to pass to the native side
      * @returns {boolean} - Success status
      */call(command,data=null){try{// Validate environment and command
-this._validateCommand(command);console.log(`🌉 Executing native command: ${command}`,data?{data}:'');// Execute on appropriate platform
+this._validateCommand(command);console.log(`🌉 Executing native command: ${command}`,data?{data}:"");// Execute on appropriate platform
 if(this.isAndroid){return this._executeAndroidCommand(command,data);}else if(this.isIOS){return this._executeIOSCommand(command,data);}return false;}catch(error){console.error(`🌉 Failed to execute command '${command}':`,error);// In development, we might want to show user-friendly errors
-if(process.env.NODE_ENV==='development'){console.warn(`🌉 Development mode: Native command '${command}' failed. This is expected when running in browser.`);}throw error;}}/**
+if(process.env.NODE_ENV==="development"){console.warn(`🌉 Development mode: Native command '${command}' failed. This is expected when running in browser.`);}throw error;}}/**
      * Camera-specific methods for easier usage
      */camera={/**
          * Open camera for photo capture
@@ -36,7 +36,7 @@ if(process.env.NODE_ENV==='development'){console.warn(`🌉 Development mode: Na
      */file={/**
          * Open file picker
          * @param {string} mimeType - MIME type filter (e.g., 'image/*', 'application/pdf')
-         */pick:(mimeType='*/*')=>this.call(_NativeInterfaces.NATIVE_COMMANDS.PICK_FILE,mimeType),/**
+         */pick:(mimeType="*/*")=>this.call(_NativeInterfaces.NATIVE_COMMANDS.PICK_FILE,mimeType),/**
          * Open file with external app
          * @param {string} fileUrl - URL of the file to open
          * @param {string} mimeType - Optional MIME type
@@ -45,11 +45,11 @@ if(process.env.NODE_ENV==='development'){console.warn(`🌉 Development mode: Na
      */haptic={/**
          * Request haptic feedback
          * @param {string} feedbackType - Type of haptic feedback
-         */feedback:(feedbackType='light')=>this.call(_NativeInterfaces.NATIVE_COMMANDS.REQUEST_HAPTIC_FEEDBACK,feedbackType)};/**
+         */feedback:(feedbackType="light")=>this.call(_NativeInterfaces.NATIVE_COMMANDS.REQUEST_HAPTIC_FEEDBACK,feedbackType)};/**
      * Get environment info
-     */getEnvironmentInfo(){return{isAndroid:this.isAndroid,isIOS:this.isIOS,isNativeEnvironment:this.isNativeEnvironment,platform:this.isAndroid?'android':this.isIOS?'ios':'web'};}/**
+     */getEnvironmentInfo(){return{isAndroid:this.isAndroid,isIOS:this.isIOS,isNativeEnvironment:this.isNativeEnvironment,platform:this.isAndroid?"android":this.isIOS?"ios":"web"};}/**
      * Check if native bridge is available
      */isAvailable(){return this.isNativeEnvironment;}/**
      * Debug method to test native bridge connectivity
-     */testConnection(){console.group('🌉 NativeBridge Connection Test');console.log('Environment:',this.getEnvironmentInfo());console.log('Available commands:',Object.values(_NativeInterfaces.NATIVE_COMMANDS));if(this.isAndroid&&window.NativeBridge){console.log('Android bridge methods:',Object.getOwnPropertyNames(window.NativeBridge));}if(this.isIOS&&window.webkit?.messageHandlers?.NativeBridge){console.log('iOS webkit bridge available');}console.groupEnd();}}// Export singleton instance
+     */testConnection(){console.group("🌉 NativeBridge Connection Test");console.log("Environment:",this.getEnvironmentInfo());console.log("Available commands:",Object.values(_NativeInterfaces.NATIVE_COMMANDS));if(this.isAndroid&&window.NativeBridge){console.log("Android bridge methods:",Object.getOwnPropertyNames(window.NativeBridge));}if(this.isIOS&&window.webkit?.messageHandlers?.NativeBridge){console.log("iOS webkit bridge available");}console.groupEnd();}}// Export singleton instance
 exports.NativeBridgeUtil=NativeBridgeUtil;const nativeBridge=new NativeBridgeUtil();var _default=exports.default=nativeBridge;// Also export the class for advanced usage

package/dist/native/buildAppAndroid.js

@@ -1,54 +1,76 @@
 "use strict";var _renameAndroidProject=require("./renameAndroidProject.js");var _setupServer=require("./setupServer.js");var _child_process=require("child_process");var _fs=_interopRequireDefault(require("fs"));var _path=_interopRequireDefault(require("path"));var _utils=require("./utils.js");var _TerminalProgress=_interopRequireDefault(require("./TerminalProgress.js"));// Import the AAB builder
-function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e};}const configPath=`${process.env.PWD}/config/config.json`;const pwd=`${process.cwd()}/node_modules/catalyst-core/dist/native`;const ANDROID_PACKAGE="io.yourname.androidproject";// Default values for AAB building
+function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e};}const configPath=`${process.env.PWD}/config/config.json`;const publicPath=`${process.env.PWD}/public`;const pwd=`${process.cwd()}/node_modules/catalyst-core/dist/native`;const ANDROID_PACKAGE="io.yourname.androidproject";// Default values for AAB building
 const DEFAULT_PROJECT_PATH=`${pwd}/androidProject`;const DEFAULT_DEPLOYMENT_PATH="./deployment";const DEFAULT_OLD_PROJECT_NAME="androidProject";// Use actual project name in catalyst
-const DEFAULT_OVERWRITE_EXISTING=true;const steps={config:'Initialize Configuration',tools:'Validate Android Tools',emulator:'Check and Start Emulator',copyAssets:'Copy Build Assets',build:'Build and Install Application',aab:'Build Signed AAB'};const progressConfig={titlePaddingTop:2,titlePaddingBottom:1,stepPaddingLeft:4,stepSpacing:1,errorPaddingLeft:6,bottomMargin:2};const progress=new _TerminalProgress.default(steps,"Catalyst Android Build",progressConfig);async function initializeConfig(){const configFile=_fs.default.readFileSync(configPath,'utf8');const config=JSON.parse(configFile);const{WEBVIEW_CONFIG}=config;if(!WEBVIEW_CONFIG||Object.keys(WEBVIEW_CONFIG).length===0){throw new Error('WebView Config missing in '+configPath);}if(!WEBVIEW_CONFIG.android){throw new Error('Android config missing in WebView Config');}// Log build type information
-const buildType=WEBVIEW_CONFIG.android.buildType||'debug';progress.log(`Build Type: ${buildType}`,'info');if(buildType==='release'){progress.log('Release build detected - AAB will be generated','info');}return{WEBVIEW_CONFIG};}function validateAndroidTools(androidConfig){const ANDROID_SDK=androidConfig.sdkPath;const ADB_PATH=`${ANDROID_SDK}/platform-tools/adb`;const EMULATOR_PATH=`${ANDROID_SDK}/emulator/emulator`;progress.log('Validating Android tools...','info');if(!ANDROID_SDK){throw new Error('Android SDK path is not configured');}if(!_fs.default.existsSync(ANDROID_SDK)){throw new Error(`Android SDK path does not exist: ${ANDROID_SDK}`);}if(!_fs.default.existsSync(ADB_PATH)){throw new Error(`ADB not found at: ${ADB_PATH}`);}try{(0,_utils.runCommand)(`${ADB_PATH} version`);progress.log('ADB validation successful','success');}catch(error){throw new Error(`ADB is not working properly: ${error.message}`);}// Skip emulator validation for release builds
-const buildType=androidConfig.buildType||'debug';if(buildType!=='release'){if(!_fs.default.existsSync(EMULATOR_PATH)){throw new Error(`Emulator not found at: ${EMULATOR_PATH}`);}try{(0,_utils.runCommand)(`${EMULATOR_PATH} -version`);progress.log('Emulator validation successful','success');}catch(error){throw new Error(`Emulator is not working properly: ${error.message}`);}try{const avdOutput=(0,_utils.runCommand)(`${EMULATOR_PATH} -list-avds`);if(!avdOutput.includes(androidConfig.emulatorName)){throw new Error(`Specified emulator "${androidConfig.emulatorName}" not found in available AVDs`);}progress.log(`Emulator "${androidConfig.emulatorName}" exists`,'success');}catch(error){throw new Error(`Error checking emulator AVD: ${error.message}`);}}else{progress.log('Skipping emulator validation for release build','info');}progress.log('Android tools validation completed successfully!','success');return{ANDROID_SDK,ADB_PATH,EMULATOR_PATH};}async function detectPhysicalDevice(ADB_PATH){try{progress.log('Detecting physical devices...','info');const devices=(0,_utils.runCommand)(`${ADB_PATH} devices -l`);const lines=devices.split('\n').filter(line=>line.trim()&&!line.includes('List of devices'));for(const line of lines){const parts=line.trim().split(/\s+/);if(parts.length>=2&&parts[1]==='device'){const deviceId=parts[0];// Check if it's a physical device (not emulator)
-if(!deviceId.startsWith('emulator-')){try{// Double-check it's not an emulator using device properties
+const DEFAULT_OVERWRITE_EXISTING=true;const steps={config:"Initialize Configuration",tools:"Validate Android Tools",emulator:"Check and Start Emulator",copyAssets:"Copy Build Assets",build:"Build and Install Application",aab:"Build Signed AAB"};const progressConfig={titlePaddingTop:2,titlePaddingBottom:1,stepPaddingLeft:4,stepSpacing:1,errorPaddingLeft:6,bottomMargin:2};const progress=new _TerminalProgress.default(steps,"Catalyst Android Build",progressConfig);async function initializeConfig(){const configFile=_fs.default.readFileSync(configPath,"utf8");const config=JSON.parse(configFile);const{WEBVIEW_CONFIG}=config;if(!WEBVIEW_CONFIG||Object.keys(WEBVIEW_CONFIG).length===0){throw new Error("WebView Config missing in "+configPath);}if(!WEBVIEW_CONFIG.android){throw new Error("Android config missing in WebView Config");}// Log build type information
+const buildType=WEBVIEW_CONFIG.android.buildType||"debug";progress.log(`Build Type: ${buildType}`,"info");if(buildType==="release"){progress.log("Release build detected - AAB will be generated","info");}return{WEBVIEW_CONFIG};}function validateAndroidTools(androidConfig){const ANDROID_SDK=androidConfig.sdkPath;const ADB_PATH=`${ANDROID_SDK}/platform-tools/adb`;const EMULATOR_PATH=`${ANDROID_SDK}/emulator/emulator`;progress.log("Validating Android tools...","info");if(!ANDROID_SDK){throw new Error("Android SDK path is not configured");}if(!_fs.default.existsSync(ANDROID_SDK)){throw new Error(`Android SDK path does not exist: ${ANDROID_SDK}`);}if(!_fs.default.existsSync(ADB_PATH)){throw new Error(`ADB not found at: ${ADB_PATH}`);}try{;(0,_utils.runCommand)(`${ADB_PATH} version`);progress.log("ADB validation successful","success");}catch(error){throw new Error(`ADB is not working properly: ${error.message}`);}// Skip emulator validation for release builds
+const buildType=androidConfig.buildType||"debug";if(buildType!=="release"){if(!_fs.default.existsSync(EMULATOR_PATH)){throw new Error(`Emulator not found at: ${EMULATOR_PATH}`);}try{;(0,_utils.runCommand)(`${EMULATOR_PATH} -version`);progress.log("Emulator validation successful","success");}catch(error){throw new Error(`Emulator is not working properly: ${error.message}`);}try{const avdOutput=(0,_utils.runCommand)(`${EMULATOR_PATH} -list-avds`);if(!avdOutput.includes(androidConfig.emulatorName)){throw new Error(`Specified emulator "${androidConfig.emulatorName}" not found in available AVDs`);}progress.log(`Emulator "${androidConfig.emulatorName}" exists`,"success");}catch(error){throw new Error(`Error checking emulator AVD: ${error.message}`);}}else{progress.log("Skipping emulator validation for release build","info");}progress.log("Android tools validation completed successfully!","success");return{ANDROID_SDK,ADB_PATH,EMULATOR_PATH};}async function detectPhysicalDevice(ADB_PATH){try{progress.log("Detecting physical devices...","info");const devices=(0,_utils.runCommand)(`${ADB_PATH} devices -l`);const lines=devices.split("\n").filter(line=>line.trim()&&!line.includes("List of devices"));for(const line of lines){const parts=line.trim().split(/\s+/);if(parts.length>=2&&parts[1]==="device"){const deviceId=parts[0];// Check if it's a physical device (not emulator)
+if(!deviceId.startsWith("emulator-")){try{// Double-check it's not an emulator using device properties
 const qemuCheck=(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell getprop ro.kernel.qemu`);if(!qemuCheck.trim()){// Empty means physical device
-progress.log(`Physical device detected: ${deviceId}`,'success');// Get device model/name for better logging
-let deviceModel='Unknown Device';try{const model=(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell getprop ro.product.model`);deviceModel=model.trim()||deviceModel;}catch(e){// Ignore model detection errors
+progress.log(`Physical device detected: ${deviceId}`,"success");// Get device model/name for better logging
+let deviceModel="Unknown Device";try{const model=(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell getprop ro.product.model`);deviceModel=model.trim()||deviceModel;}catch(e){// Ignore model detection errors
 }return{id:deviceId,model:deviceModel};}}catch(error){// If we can't check properties, skip this device
-continue;}}}}progress.log('No physical devices detected','info');return null;}catch(error){progress.log('Error detecting physical devices: '+error.message,'error');return null;}}async function testPhysicalDeviceInstallation(ADB_PATH,deviceId){try{progress.log(`Testing installation capability on device ${deviceId}...`,'info');// Test 1: Basic ADB connection
-const connectionTest=(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell echo "test"`);if(!connectionTest.includes('test')){progress.log('Device connection test failed','error');return false;}// Test 2: Check if developer options are enabled
-try{const developerOptions=(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell settings get global development_settings_enabled`);if(developerOptions.trim()!=='1'){progress.log('Developer options not enabled on device','warning');return false;}}catch(error){progress.log('Cannot verify developer options status','warning');}// Test 3: Check USB debugging status
-try{const usbDebugging=(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell settings get global adb_enabled`);if(usbDebugging.trim()!=='1'){progress.log('USB debugging not enabled on device','warning');return false;}}catch(error){progress.log('Cannot verify USB debugging status','warning');}// Test 4: Check if we can access package manager
-try{(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell pm list packages -3 | head -1`);}catch(error){progress.log('Cannot access package manager on device','error');return false;}progress.log(`Device ${deviceId} is ready for installation`,'success');return true;}catch(error){progress.log(`Installation capability test failed: ${error.message}`,'error');return false;}}async function checkEmulator(ADB_PATH){try{const devices=(0,_utils.runCommand)(`${ADB_PATH} devices`);return devices.includes('emulator');}catch(error){progress.log('Error checking emulator status: '+error.message,'error');return false;}}async function handleEmulatorSetup(ADB_PATH,EMULATOR_PATH,androidConfig){progress.log('Setting up emulator...','info');const emulatorRunning=await checkEmulator(ADB_PATH);if(!emulatorRunning){progress.log('No emulator running, attempting to start one...','info');await startEmulator(EMULATOR_PATH,androidConfig);await new Promise(resolve=>setTimeout(resolve,5000));}else{progress.log('Emulator already running','success');}return{type:'emulator',name:androidConfig.emulatorName};}async function startEmulator(EMULATOR_PATH,androidConfig){progress.log(`Starting emulator: ${androidConfig.emulatorName}...`,'info');return new Promise((resolve,reject)=>{(0,_child_process.exec)(`${EMULATOR_PATH} -avd ${androidConfig.emulatorName} -read-only > /dev/null &`,(error,stdout,stderr)=>{if(error){progress.log('Error starting emulator: '+error.message,'error');reject(error);}else{progress.log('Emulator started successfully','success');resolve();}});});}async function copyBuildAssets(androidConfig,buildOptimisation=false){if(!buildOptimisation)return;progress.log('Copying build assets to Android project...','info');try{// Define source and destination paths
-const sourcePath=`${process.env.PWD}/build/`;const destPath=`${pwd}/androidProject/app/src/main/assets/build/`;// Create destination directory if it doesn't exist
-(0,_utils.runCommand)(`mkdir -p ${destPath}`);// Clear existing destination to avoid conflicts
-(0,_utils.runCommand)(`rm -rf ${destPath}/*`);// Files to exclude from copying
-const excludePatterns=['route-manifest.json.gz','route-manifest.json.br'];if(buildOptimisation){progress.log('Running with build optimization...','info');const excludeParams=excludePatterns.map(pattern=>`--exclude="${pattern}"`).join(' ');const rsyncCommand=`rsync -av ${excludeParams} ${sourcePath} ${destPath}`;progress.log('Executing rsync command with exclusions...','info');(0,_utils.runCommand)(rsyncCommand);// Verify excluded files don't exist in destination
-for(const pattern of excludePatterns){const checkCommand=`find ${destPath} -name "${pattern}" | wc -l`;const count=parseInt((0,_utils.runCommand)(checkCommand).trim(),10);if(count>0){progress.log(`Warning: Found ${count} instances of excluded file ${pattern}`,'warning');(0,_utils.runCommand)(`find ${destPath} -name "${pattern}" -delete`);}}progress.log('Build assets copied with optimization (excluded route-manifest JSON files)','success');}else{progress.log('Running without build optimization...','info');const exclusions=excludePatterns.map(pattern=>`-not -name "${pattern}"`).join(' ');const copyCommand=`find ${sourcePath} -type f ${exclusions} -exec cp --parents {} ${destPath} \\;`;progress.log(`Executing copy command with exclusions...`,'info');(0,_utils.runCommand)(copyCommand);progress.log('Build assets copied successfully!','success');}}catch(error){throw new Error('Error copying build assets: '+error.message);}}async function buildApp(ADB_PATH,androidConfig,buildOptimisation,buildType='debug',targetDevice=null){progress.log('Building and installing app...','info');try{// Build command without monkey launch
+continue;}}}}progress.log("No physical devices detected","info");return null;}catch(error){progress.log("Error detecting physical devices: "+error.message,"error");return null;}}async function testPhysicalDeviceInstallation(ADB_PATH,deviceId){try{progress.log(`Testing installation capability on device ${deviceId}...`,"info");// Test 1: Basic ADB connection
+const connectionTest=(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell echo "test"`);if(!connectionTest.includes("test")){progress.log("Device connection test failed","error");return false;}// Test 2: Check if developer options are enabled
+try{const developerOptions=(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell settings get global development_settings_enabled`);if(developerOptions.trim()!=="1"){progress.log("Developer options not enabled on device","warning");return false;}}catch(error){progress.log("Cannot verify developer options status","warning");}// Test 3: Check USB debugging status
+try{const usbDebugging=(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell settings get global adb_enabled`);if(usbDebugging.trim()!=="1"){progress.log("USB debugging not enabled on device","warning");return false;}}catch(error){progress.log("Cannot verify USB debugging status","warning");}// Test 4: Check if we can access package manager
+try{;(0,_utils.runCommand)(`${ADB_PATH} -s ${deviceId} shell pm list packages -3 | head -1`);}catch(error){progress.log("Cannot access package manager on device","error");return false;}progress.log(`Device ${deviceId} is ready for installation`,"success");return true;}catch(error){progress.log(`Installation capability test failed: ${error.message}`,"error");return false;}}async function checkEmulator(ADB_PATH){try{const devices=(0,_utils.runCommand)(`${ADB_PATH} devices`);return devices.includes("emulator");}catch(error){progress.log("Error checking emulator status: "+error.message,"error");return false;}}async function handleEmulatorSetup(ADB_PATH,EMULATOR_PATH,androidConfig){progress.log("Setting up emulator...","info");const emulatorRunning=await checkEmulator(ADB_PATH);if(!emulatorRunning){progress.log("No emulator running, attempting to start one...","info");await startEmulator(EMULATOR_PATH,androidConfig);await new Promise(resolve=>setTimeout(resolve,5000));}else{progress.log("Emulator already running","success");}return{type:"emulator",name:androidConfig.emulatorName};}async function startEmulator(EMULATOR_PATH,androidConfig){progress.log(`Starting emulator: ${androidConfig.emulatorName}...`,"info");return new Promise((resolve,reject)=>{;(0,_child_process.exec)(`${EMULATOR_PATH} -avd ${androidConfig.emulatorName} -read-only > /dev/null &`,(error,stdout,stderr)=>{if(error){progress.log("Error starting emulator: "+error.message,"error");reject(error);}else{progress.log("Emulator started successfully","success");resolve();}});});}async function copyBuildAssets(androidConfig,buildOptimisation=false){if(!buildOptimisation)return;progress.log("Copying build assets to Android project...","info");try{// Define source and destination paths
+const sourcePath=`${process.env.PWD}/build/`;const destPath=`${pwd}/androidProject/app/src/main/assets/build/`// Create destination directory if it doesn't exist
+;(0,_utils.runCommand)(`mkdir -p ${destPath}`)// Clear existing destination to avoid conflicts
+;(0,_utils.runCommand)(`rm -rf ${destPath}/*`);// Files to exclude from copying
+const excludePatterns=["route-manifest.json.gz","route-manifest.json.br"];if(buildOptimisation){progress.log("Running with build optimization...","info");const excludeParams=excludePatterns.map(pattern=>`--exclude="${pattern}"`).join(" ");const rsyncCommand=`rsync -av ${excludeParams} ${sourcePath} ${destPath}`;progress.log("Executing rsync command with exclusions...","info");(0,_utils.runCommand)(rsyncCommand);// Verify excluded files don't exist in destination
+for(const pattern of excludePatterns){const checkCommand=`find ${destPath} -name "${pattern}" | wc -l`;const count=parseInt((0,_utils.runCommand)(checkCommand).trim(),10);if(count>0){progress.log(`Warning: Found ${count} instances of excluded file ${pattern}`,"warning");(0,_utils.runCommand)(`find ${destPath} -name "${pattern}" -delete`);}}progress.log("Build assets copied with optimization (excluded route-manifest JSON files)","success");}else{progress.log("Running without build optimization...","info");const exclusions=excludePatterns.map(pattern=>`-not -name "${pattern}"`).join(" ");const copyCommand=`find ${sourcePath} -type f ${exclusions} -exec cp --parents {} ${destPath} \\;`;progress.log(`Executing copy command with exclusions...`,"info");(0,_utils.runCommand)(copyCommand);progress.log("Build assets copied successfully!","success");}}catch(error){throw new Error("Error copying build assets: "+error.message);}}async function buildApp(ADB_PATH,androidConfig,buildOptimisation,buildType="debug",targetDevice=null){progress.log("Building and installing app...","info");try{// Build command without monkey launch
 let buildCommand=`cd ${pwd}/androidProject && ./gradlew generateWebViewConfig -PconfigPath=${configPath} -PbuildOptimisation=${buildOptimisation} && ./gradlew clean installDebug --quiet --console=rich`;// Add device-specific install target if physical device
-if(targetDevice&&targetDevice.type==='physical'){buildCommand=buildCommand.replace('installDebug',`installDebug -Pandroid.injected.target.device=${targetDevice.id}`);}await(0,_utils.runInteractiveCommand)('sh',['-c',buildCommand],{'BUILD SUCCESSFUL':''});progress.log('App build and installation completed successfully!','success');}catch(error){throw new Error('Error building/installing app: '+error.message);}}async function launchApp(ADB_PATH,buildType='debug',targetDevice=null){if(!targetDevice){progress.log('No target device specified, skipping launch','warning');return;}if(targetDevice.type==='physical'){progress.log(`App installed on physical device: ${targetDevice.model}`,'success');progress.log('Manual launch required - check your device to open the app','info');return;}// Launch on emulator
-try{progress.log('Launching app on emulator...','info');const packageName=`${ANDROID_PACKAGE}${buildType==='debug'?'.debug':''}`;const launchCommand=`${ADB_PATH} shell monkey -p ${packageName} 1`;await(0,_utils.runInteractiveCommand)('sh',['-c',launchCommand],{});progress.log('App launched successfully on emulator!','success');}catch(error){progress.log(`Warning: Could not auto-launch app: ${error.message}`,'warning');progress.log('App was installed successfully, but auto-launch failed','info');}}// Legacy function for backward compatibility
-async function installApp(ADB_PATH,androidConfig,buildOptimisation,buildType='debug'){await buildApp(ADB_PATH,androidConfig,buildOptimisation,buildType);await launchApp(ADB_PATH,buildType,{type:'emulator'});}async function createAABConfig(androidConfig){// Create AAB configuration based on WebView config with defaults applied
+if(targetDevice&&targetDevice.type==="physical"){buildCommand=buildCommand.replace("installDebug",`installDebug -Pandroid.injected.target.device=${targetDevice.id}`);}await(0,_utils.runInteractiveCommand)("sh",["-c",buildCommand],{"BUILD SUCCESSFUL":""});progress.log("App build and installation completed successfully!","success");}catch(error){throw new Error("Error building/installing app: "+error.message);}}async function launchApp(ADB_PATH,buildType="debug",targetDevice=null){if(!targetDevice){progress.log("No target device specified, skipping launch","warning");return;}if(targetDevice.type==="physical"){progress.log(`App installed on physical device: ${targetDevice.model}`,"success");progress.log("Manual launch required - check your device to open the app","info");return;}// Launch on emulator
+try{progress.log("Launching app on emulator...","info");const packageName=`${ANDROID_PACKAGE}${buildType==="debug"?".debug":""}`;const launchCommand=`${ADB_PATH} shell monkey -p ${packageName} 1`;await(0,_utils.runInteractiveCommand)("sh",["-c",launchCommand],{});progress.log("App launched successfully on emulator!","success");}catch(error){progress.log(`Warning: Could not auto-launch app: ${error.message}`,"warning");progress.log("App was installed successfully, but auto-launch failed","info");}}async function copySplashscreenAssets(){try{const sourcePath=`${process.env.PWD}/build/`;const destPath=`${pwd}/androidProject/app/src/main/res`;const configFile=_fs.default.readFileSync(configPath,"utf8");const config=JSON.parse(configFile);const{WEBVIEW_CONFIG={}}=config;const themesFile=`${destPath}/values/themes.xml`;const themesNightFile=`${destPath}/values-night/themes.xml`;let themesContent=_fs.default.readFileSync(themesFile,"utf8");let themesNightContent=_fs.default.readFileSync(themesNightFile,"utf8");const colorsFile=`${destPath}/values/colors.xml`;let colorsContent=_fs.default.readFileSync(colorsFile,"utf8");const splashscreenProperties={icon:'<item name="android:windowSplashScreenAnimatedIcon">@drawable/splashscreen</item>',backgroundColor:'<item name="android:windowSplashScreenBackground">@color/splashscreen_background</item>'};const hasSplashscreenConfig=!!WEBVIEW_CONFIG.splashScreen;// Always remove splashscreen properties and colors first (regardless of config)
+themesContent=themesContent.replace(splashscreenProperties.backgroundColor,"");themesContent=themesContent.replace(splashscreenProperties.icon,"");themesNightContent=themesNightContent.replace(splashscreenProperties.backgroundColor,"");themesNightContent=themesNightContent.replace(splashscreenProperties.icon,"");// Also remove splashscreen color from colors.xml
+const existingColorLine=colorsContent.split("\n").find(line=>line.includes('name="splashscreen_background"'));if(existingColorLine){colorsContent=colorsContent.replace(existingColorLine,"");}if(!hasSplashscreenConfig){progress.log("Removed splashscreen properties from themes.xml and colors.xml","info");_fs.default.writeFileSync(colorsFile,colorsContent);_fs.default.writeFileSync(themesFile,themesContent);_fs.default.writeFileSync(themesNightFile,themesNightContent);return;}const styleEndTag="</style>";const insertPosition=themesContent.lastIndexOf(styleEndTag);if(insertPosition!==-1){const beforeStyle=themesContent.substring(0,insertPosition).trimEnd();const afterStyle=themesContent.substring(insertPosition);const splashscreenProps=Object.values(splashscreenProperties).map(prop=>`\t\t${prop}`).join("\n");// Insert properties with proper spacing
+themesContent=beforeStyle+"\n"+splashscreenProps+"\n\t"+afterStyle;progress.log("Added splashscreen properties to themes.xml","info");}const nightInsertPosition=themesNightContent.lastIndexOf(styleEndTag);if(nightInsertPosition!==-1){const beforeNightStyle=themesNightContent.substring(0,nightInsertPosition).trimEnd();const afterNightStyle=themesNightContent.substring(nightInsertPosition);const splashscreenProps=Object.values(splashscreenProperties).map(prop=>`\t\t${prop}`).join("\n");// Insert properties with proper spacing
+themesNightContent=beforeNightStyle+"\n"+splashscreenProps+"\n\t"+afterNightStyle;progress.log("Added splashscreen properties to themes-night.xml","info");}_fs.default.writeFileSync(themesFile,themesContent);_fs.default.writeFileSync(themesNightFile,themesNightContent);// Check for splashscreen image file in public directory
+const imageFormats=["png","jpg","jpeg","gif","bmp","svg","webp"];let splashscreenImageFound=false;// Ensure public directory exists
+if(!_fs.default.existsSync(publicPath)){progress.log(`Warning: Public directory not found at ${publicPath}`,"warning");return;}// Create drawable directory if it doesn't exist
+const drawableDir=`${destPath}/drawable`;if(!_fs.default.existsSync(drawableDir)){_fs.default.mkdirSync(drawableDir,{recursive:true});}// Remove existing splashscreen assets to avoid conflicts
+for(const format of imageFormats){const existingSplashscreenPath=`${destPath}/drawable/splashscreen.${format}`;if(_fs.default.existsSync(existingSplashscreenPath)){_fs.default.unlinkSync(existingSplashscreenPath);progress.log(`Removed existing splashscreen.${format}`,"info");}}for(const format of imageFormats){const splashscreenImagePath=`${publicPath}/splashscreen.${format}`;if(_fs.default.existsSync(splashscreenImagePath)){// Copy splashscreen image to drawable directory
+const destImagePath=`${destPath}/drawable/splashscreen.${format}`;_fs.default.copyFileSync(splashscreenImagePath,destImagePath);progress.log(`Splashscreen image copied: splashscreen.${format}`,"success");splashscreenImageFound=true;break;}}if(!splashscreenImageFound){// Use the default Android launcher icon
+const launcherIconPath=`${destPath}/drawable/splashscreen_fallback.png`;const destinationPath=`${destPath}/drawable/splashscreen.png`;if(_fs.default.existsSync(launcherIconPath)){_fs.default.copyFileSync(launcherIconPath,destinationPath);progress.log("Using default Android launcher icon as splashscreen","info");}}const backgroundColor=WEBVIEW_CONFIG.splashScreen?.backgroundColor||"#FFFFFF";// Ensure color starts with # and convert to Android format
+const androidColor=backgroundColor.startsWith("#")?`#FF${backgroundColor.slice(1).toUpperCase()}`:`#FF${backgroundColor.toUpperCase()}`;const newColorEntry=`\t<color name="splashscreen_background">${androidColor}</color>`;colorsContent=colorsContent.replace("</resources>",`${newColorEntry}\n</resources>`);_fs.default.writeFileSync(colorsFile,colorsContent);if(!WEBVIEW_CONFIG.splashScreen?.backgroundColor){progress.log("Using fallback background color: #FFFFFF","info");}progress.log("Splashscreen assets copied successfully!","success");}catch(error){progress.log(`Warning: Error copying splashscreen assets: ${error.message}`,"warning");}}async function copyIconAssets(){try{const destPath=`${pwd}/androidProject/app/src/main/res`;const manifestPath=`${pwd}/androidProject/app/src/main/AndroidManifest.xml`;// Check for icon image file in public directory
+const imageFormats=["png","jpg","jpeg","gif","bmp","svg","webp"];let iconImageFound=false;// Ensure public directory exists
+if(!_fs.default.existsSync(publicPath)){progress.log(`Warning: Public directory not found at ${publicPath}`,"warning");return;}// Create drawable directory if it doesn't exist
+const drawableDir=`${destPath}/drawable`;if(!_fs.default.existsSync(drawableDir)){_fs.default.mkdirSync(drawableDir,{recursive:true});}// Remove existing custom icon assets to avoid conflicts
+for(const format of imageFormats){const existingIconPath=`${destPath}/drawable/icon.${format}`;if(_fs.default.existsSync(existingIconPath)){_fs.default.unlinkSync(existingIconPath);progress.log(`Removed existing icon.${format}`,"info");}}// Look for icon in public directory
+for(const format of imageFormats){const iconImagePath=`${publicPath}/icon.${format}`;if(_fs.default.existsSync(iconImagePath)){// Copy icon image to drawable directory
+const destImagePath=`${destPath}/drawable/icon.${format}`;_fs.default.copyFileSync(iconImagePath,destImagePath);progress.log(`App icon copied: icon.${format} -> icon.${format}`,"success");iconImageFound=true;break;}}// If no custom icon found, just log and return (keep default icon)
+if(!iconImageFound){progress.log("No custom app icon found (icon.png/jpg/jpeg), using default","info");if(_fs.default.existsSync(manifestPath)){let manifestContent=_fs.default.readFileSync(manifestPath,"utf8");// Only revert if manifest currently references custom icon
+if(manifestContent.includes('android:icon="@drawable/icon"')){manifestContent=manifestContent.replace(/android:icon="@drawable\/icon"/,'android:icon="@mipmap/ic_launcher"');manifestContent=manifestContent.replace(/android:roundIcon="@drawable\/icon"/,'android:roundIcon="@mipmap/ic_launcher_round"');_fs.default.writeFileSync(manifestPath,manifestContent);progress.log("Reverted AndroidManifest.xml to use default launcher icon","info");}}return;}// Update AndroidManifest.xml if it exists
+if(_fs.default.existsSync(manifestPath)){let manifestContent=_fs.default.readFileSync(manifestPath,"utf8");// Look for the application tag and update the icon reference
+const applicationTagRegex=/<application([^>]*android:icon="[^"]*"[^>]*>)/;const iconAttributeRegex=/android:icon="[^"]*"/;const roundIconAttributeRegex=/android:roundIcon="[^"]*"/;if(applicationTagRegex.test(manifestContent)){// Replace existing icon attribute
+manifestContent=manifestContent.replace(iconAttributeRegex,'android:icon="@drawable/icon"');manifestContent=manifestContent.replace(roundIconAttributeRegex,'android:roundIcon="@drawable/icon"');progress.log("Updated app icon reference in AndroidManifest.xml","success");}_fs.default.writeFileSync(manifestPath,manifestContent);}progress.log("App icon assets processed successfully!","success");}catch(error){progress.log(`Warning: Error copying app icon assets: ${error.message}`,"warning");}}// Legacy function for backward compatibility
+async function installApp(ADB_PATH,androidConfig,buildOptimisation,buildType="debug"){await buildApp(ADB_PATH,androidConfig,buildOptimisation,buildType);await launchApp(ADB_PATH,buildType,{type:"emulator"});}async function createAABConfig(androidConfig){// Create AAB configuration based on WebView config with defaults applied
 const aabConfig={// Apply defaults here in buildAppAndroid.js
 projectPath:androidConfig.projectPath||DEFAULT_PROJECT_PATH,deploymentPath:DEFAULT_DEPLOYMENT_PATH,oldProjectName:DEFAULT_OLD_PROJECT_NAME,overwriteExisting:androidConfig.overwriteExisting!==undefined?androidConfig.overwriteExisting:DEFAULT_OVERWRITE_EXISTING,// Required field - use configured value or derive from other config
-newProjectName:androidConfig.newProjectName||androidConfig.appName||androidConfig.packageName?.split('.').pop()||"catalystapp",// AAB specific settings
+newProjectName:androidConfig.newProjectName||androidConfig.appName||androidConfig.packageName?.split(".").pop()||"catalystapp",// AAB specific settings
 createSignedAAB:true,outputPath:androidConfig.outputPath||`${process.env.PWD}/build-output`};// Add keystore configuration if available
 if(androidConfig.keystoreConfig){aabConfig.keystoreConfig=androidConfig.keystoreConfig;}else if(androidConfig.keystore){// Map old keystore format to new format
 aabConfig.keystoreConfig={keyAlias:androidConfig.keystore.alias||"release",storePassword:androidConfig.keystore.storePassword,keyPassword:androidConfig.keystore.keyPassword,validityYears:25,organizationInfo:{companyName:androidConfig.keystore.organizationName||"YourCompany",city:androidConfig.keystore.city||"YourCity",state:androidConfig.keystore.state||"YourState",countryCode:androidConfig.keystore.countryCode||"US"}};}// Log the configuration being used
-progress.log(`AAB Configuration:`,'info');progress.log(`  Project Path: ${aabConfig.projectPath} ${aabConfig.projectPath===DEFAULT_PROJECT_PATH?'(default)':'(configured)'}`,'info');progress.log(`  Deployment Path: ${aabConfig.deploymentPath} ${aabConfig.deploymentPath===DEFAULT_DEPLOYMENT_PATH?'(default)':'(configured)'}`,'info');progress.log(`  Old Project Name: ${aabConfig.oldProjectName} ${aabConfig.oldProjectName===DEFAULT_OLD_PROJECT_NAME?'(default)':'(configured)'}`,'info');progress.log(`  New Project Name: ${aabConfig.newProjectName}`,'info');progress.log(`  Overwrite Existing: ${aabConfig.overwriteExisting} ${aabConfig.overwriteExisting===DEFAULT_OVERWRITE_EXISTING?'(default)':'(configured)'}`,'info');progress.log(`  Output Path: ${aabConfig.outputPath}`,'info');return aabConfig;}async function buildSignedAAB(androidConfig){progress.log('Building signed AAB for release...','info');try{// Create AAB configuration directly without temporary file
+progress.log(`AAB Configuration:`,"info");progress.log(`  Project Path: ${aabConfig.projectPath} ${aabConfig.projectPath===DEFAULT_PROJECT_PATH?"(default)":"(configured)"}`,"info");progress.log(`  Deployment Path: ${aabConfig.deploymentPath} ${aabConfig.deploymentPath===DEFAULT_DEPLOYMENT_PATH?"(default)":"(configured)"}`,"info");progress.log(`  Old Project Name: ${aabConfig.oldProjectName} ${aabConfig.oldProjectName===DEFAULT_OLD_PROJECT_NAME?"(default)":"(configured)"}`,"info");progress.log(`  New Project Name: ${aabConfig.newProjectName}`,"info");progress.log(`  Overwrite Existing: ${aabConfig.overwriteExisting} ${aabConfig.overwriteExisting===DEFAULT_OVERWRITE_EXISTING?"(default)":"(configured)"}`,"info");progress.log(`  Output Path: ${aabConfig.outputPath}`,"info");return aabConfig;}async function buildSignedAAB(androidConfig){progress.log("Building signed AAB for release...","info");try{// Create AAB configuration directly without temporary file
 const aabConfig=await createAABConfig(androidConfig);// Call the AAB builder directly with config object
-await(0,_renameAndroidProject.buildAndroidAAB)(aabConfig);progress.log('Signed AAB build completed successfully!','success');}catch(error){throw new Error('Error building signed AAB: '+error.message);}}async function buildAndroidApp(){// Initialize androidConfig outside try block to ensure it's available in catch
+await(0,_renameAndroidProject.buildAndroidAAB)(aabConfig);progress.log("Signed AAB build completed successfully!","success");}catch(error){throw new Error("Error building signed AAB: "+error.message);}}async function buildAndroidApp(){// Initialize androidConfig outside try block to ensure it's available in catch
 let androidConfig=null;try{await(0,_setupServer.setupServer)(configPath);// Initialize configuration
-progress.start('config');const{WEBVIEW_CONFIG}=await initializeConfig();androidConfig=WEBVIEW_CONFIG.android;const buildType=androidConfig.buildType||'debug';const buildOptimisation=!!androidConfig.buildOptimisation||false;progress.complete('config');// Validate tools and get paths
-progress.start('tools');const{ANDROID_SDK,ADB_PATH,EMULATOR_PATH}=await validateAndroidTools(androidConfig);progress.complete('tools');// Device detection and setup (skip for release builds)
-let targetDevice=null;if(buildType!=='release'){progress.start('emulator');// Step 1: Check for physical device first
-const physicalDevice=await detectPhysicalDevice(ADB_PATH);if(physicalDevice){progress.log(`Found physical device: ${physicalDevice.model} (${physicalDevice.id})`,'success');// Test if we can install on physical device
+progress.start("config");const{WEBVIEW_CONFIG}=await initializeConfig();androidConfig=WEBVIEW_CONFIG.android;const buildType=androidConfig.buildType||"debug";const buildOptimisation=!!androidConfig.buildOptimisation||false;progress.complete("config");// Validate tools and get paths
+progress.start("tools");const{ANDROID_SDK,ADB_PATH,EMULATOR_PATH}=await validateAndroidTools(androidConfig);progress.complete("tools");// Device detection and setup (skip for release builds)
+let targetDevice=null;if(buildType!=="release"){progress.start("emulator");// Step 1: Check for physical device first
+const physicalDevice=await detectPhysicalDevice(ADB_PATH);if(physicalDevice){progress.log(`Found physical device: ${physicalDevice.model} (${physicalDevice.id})`,"success");// Test if we can install on physical device
 const canInstallOnPhysical=await testPhysicalDeviceInstallation(ADB_PATH,physicalDevice.id);if(canInstallOnPhysical){// Use physical device - skip emulator entirely
-targetDevice={type:'physical',id:physicalDevice.id,model:physicalDevice.model};progress.log(`Using physical device: ${physicalDevice.model}`,'success');}else{// Physical device failed, fallback to emulator
-progress.log('Physical device installation test failed, falling back to emulator','warning');targetDevice=await handleEmulatorSetup(ADB_PATH,EMULATOR_PATH,androidConfig);}}else{// No physical device, use emulator (current behavior)
-targetDevice=await handleEmulatorSetup(ADB_PATH,EMULATOR_PATH,androidConfig);}progress.complete('emulator');}else{progress.log('Skipping device setup for release build','info');}// Copy build assets
-progress.start('copyAssets');await copyBuildAssets(androidConfig,buildOptimisation);progress.log(`Build optimization: ${buildOptimisation?'Enabled':'Disabled'}`,'info');progress.complete('copyAssets');// Build based on type
-if(buildType==='release'){// Build signed AAB for release
-progress.start('aab');await buildSignedAAB(androidConfig);progress.complete('aab');}else{// Install debug app for development
-progress.start('build');await buildApp(ADB_PATH,androidConfig,buildOptimisation,buildType,targetDevice);await launchApp(ADB_PATH,buildType,targetDevice);progress.complete('build');}// Print build summary
-const summaryItems=['Build completed successfully:',{text:`Build Type: ${buildType}`,indent:1,prefix:'├─ ',color:'gray'},{text:`SDK Path: ${androidConfig.sdkPath}`,indent:1,prefix:'├─ ',color:'gray'},{text:`Build Optimization: ${buildOptimisation?'Enabled':'Disabled'}`,indent:1,prefix:'├─ ',color:'gray'}];if(buildType==='release'){summaryItems.push({text:`Output: Signed AAB generated in build-output/`,indent:1,prefix:'└─ ',color:'green'});}else{if(targetDevice&&targetDevice.type==='physical'){summaryItems.push({text:`Target Device: ${targetDevice.model} (Physical)`,indent:1,prefix:'└─ ',color:'green'});}else{summaryItems.push({text:`Target Device: ${androidConfig.emulatorName} (Emulator)`,indent:1,prefix:'└─ ',color:'gray'});}}progress.printTreeContent('Build Summary',summaryItems);process.exit(0);}catch(error){if(progress.currentStep){progress.fail(progress.currentStep.id,error.message);const troubleshootingItems=['Build failed. Please try the following steps:',{text:'Check if Android SDK is properly configured',indent:1,prefix:'├─ ',color:'yellow'},{text:'Verify build assets exist in the source directory',indent:1,prefix:'├─ ',color:'yellow'}];// Use androidConfig safely with null checks
-const buildType=androidConfig?.buildType||'debug';// Device-specific troubleshooting
-if(buildType!=='release'){// Check if error is related to device issues
-if(error.message.includes('physical device')||error.message.includes('installation test')){troubleshootingItems.push('\nPhysical Device Issues:',{text:'Enable Developer Options on your device',indent:1,prefix:'├─ ',color:'yellow'},{text:'Enable USB Debugging in Developer Options',indent:1,prefix:'├─ ',color:'yellow'},{text:'Accept the "Allow USB Debugging" prompt on your device',indent:1,prefix:'├─ ',color:'yellow'},{text:'Try disconnecting and reconnecting your device',indent:1,prefix:'├─ ',color:'yellow'},{text:'Check if "adb devices" shows your device as authorized',indent:1,prefix:'├─ ',color:'yellow'});}if(buildType==='release'){troubleshootingItems.push({text:'Verify keystore configuration for release builds',indent:1,prefix:'├─ ',color:'yellow'},{text:'Check that keystore passwords are properly set',indent:1,prefix:'├─ ',color:'yellow'});}else{troubleshootingItems.push({text:'Verify that the emulator exists and is working',indent:1,prefix:'├─ ',color:'yellow'},{text:'If using physical device, ensure it stays connected',indent:1,prefix:'├─ ',color:'yellow'});}}else{troubleshootingItems.push({text:'Verify keystore configuration for release builds',indent:1,prefix:'├─ ',color:'yellow'},{text:'Check that keystore passwords are properly set',indent:1,prefix:'├─ ',color:'yellow'});}troubleshootingItems.push({text:'Run "npm run setupEmulator:android" to reconfigure Android settings',indent:1,prefix:'└─ ',color:'yellow'},'\nVerify Configuration:');// Add configuration details only if androidConfig is available
-if(androidConfig){troubleshootingItems.push({text:`Build Type: ${buildType}`,indent:1,prefix:'├─ ',color:'gray'},{text:`Android SDK Path: ${androidConfig.sdkPath||'Not configured'}`,indent:1,prefix:'├─ ',color:'gray'});if(buildType!=='release'){// Show device information if available
-if(targetDevice){troubleshootingItems.push({text:`Target Device: ${targetDevice.type==='physical'?`${targetDevice.model} (Physical)`:`${androidConfig.emulatorName} (Emulator)`}`,indent:1,prefix:'└─ ',color:'gray'});}else{troubleshootingItems.push({text:`Selected Emulator: ${androidConfig.emulatorName||'Not configured'}`,indent:1,prefix:'└─ ',color:'gray'});}}else{troubleshootingItems.push({text:`Output Path: ${androidConfig.outputPath||'build-output/'}`,indent:1,prefix:'└─ ',color:'gray'});}}else{troubleshootingItems.push({text:'Configuration could not be loaded',indent:1,prefix:'├─ ',color:'red'},{text:'Check if config/config.json exists and has valid Android configuration',indent:1,prefix:'└─ ',color:'red'});}progress.printTreeContent('Troubleshooting Guide',troubleshootingItems);}process.exit(1);}}// Execute the main build process
+targetDevice={type:"physical",id:physicalDevice.id,model:physicalDevice.model};progress.log(`Using physical device: ${physicalDevice.model}`,"success");}else{// Physical device failed, fallback to emulator
+progress.log("Physical device installation test failed, falling back to emulator","warning");targetDevice=await handleEmulatorSetup(ADB_PATH,EMULATOR_PATH,androidConfig);}}else{// No physical device, use emulator (current behavior)
+targetDevice=await handleEmulatorSetup(ADB_PATH,EMULATOR_PATH,androidConfig);}progress.complete("emulator");}else{progress.log("Skipping device setup for release build","info");}// Copy build assets
+progress.start("copyAssets");await copyBuildAssets(androidConfig,buildOptimisation);await copySplashscreenAssets();await copyIconAssets();progress.log(`Build optimization: ${buildOptimisation?"Enabled":"Disabled"}`,"info");progress.complete("copyAssets");// Build based on type
+if(buildType==="release"){// Build signed AAB for release
+progress.start("aab");await buildSignedAAB(androidConfig);progress.complete("aab");}else{// Install debug app for development
+progress.start("build");await buildApp(ADB_PATH,androidConfig,buildOptimisation,buildType,targetDevice);await launchApp(ADB_PATH,buildType,targetDevice);progress.complete("build");}// Print build summary
+const summaryItems=["Build completed successfully:",{text:`Build Type: ${buildType}`,indent:1,prefix:"├─ ",color:"gray"},{text:`SDK Path: ${androidConfig.sdkPath}`,indent:1,prefix:"├─ ",color:"gray"},{text:`Build Optimization: ${buildOptimisation?"Enabled":"Disabled"}`,indent:1,prefix:"├─ ",color:"gray"}];if(buildType==="release"){summaryItems.push({text:`Output: Signed AAB generated in build-output/`,indent:1,prefix:"└─ ",color:"green"});}else{if(targetDevice&&targetDevice.type==="physical"){summaryItems.push({text:`Target Device: ${targetDevice.model} (Physical)`,indent:1,prefix:"└─ ",color:"green"});}else{summaryItems.push({text:`Target Device: ${androidConfig.emulatorName} (Emulator)`,indent:1,prefix:"└─ ",color:"gray"});}}progress.printTreeContent("Build Summary",summaryItems);process.exit(0);}catch(error){if(progress.currentStep){progress.fail(progress.currentStep.id,error.message);const troubleshootingItems=["Build failed. Please try the following steps:",{text:"Check if Android SDK is properly configured",indent:1,prefix:"├─ ",color:"yellow"},{text:"Verify build assets exist in the source directory",indent:1,prefix:"├─ ",color:"yellow"}];// Use androidConfig safely with null checks
+const buildType=androidConfig?.buildType||"debug";// Device-specific troubleshooting
+if(buildType!=="release"){// Check if error is related to device issues
+if(error.message.includes("physical device")||error.message.includes("installation test")){troubleshootingItems.push("\nPhysical Device Issues:",{text:"Enable Developer Options on your device",indent:1,prefix:"├─ ",color:"yellow"},{text:"Enable USB Debugging in Developer Options",indent:1,prefix:"├─ ",color:"yellow"},{text:'Accept the "Allow USB Debugging" prompt on your device',indent:1,prefix:"├─ ",color:"yellow"},{text:"Try disconnecting and reconnecting your device",indent:1,prefix:"├─ ",color:"yellow"},{text:'Check if "adb devices" shows your device as authorized',indent:1,prefix:"├─ ",color:"yellow"});}if(buildType==="release"){troubleshootingItems.push({text:"Verify keystore configuration for release builds",indent:1,prefix:"├─ ",color:"yellow"},{text:"Check that keystore passwords are properly set",indent:1,prefix:"├─ ",color:"yellow"});}else{troubleshootingItems.push({text:"Verify that the emulator exists and is working",indent:1,prefix:"├─ ",color:"yellow"},{text:"If using physical device, ensure it stays connected",indent:1,prefix:"├─ ",color:"yellow"});}}else{troubleshootingItems.push({text:"Verify keystore configuration for release builds",indent:1,prefix:"├─ ",color:"yellow"},{text:"Check that keystore passwords are properly set",indent:1,prefix:"├─ ",color:"yellow"});}troubleshootingItems.push({text:'Run "npm run setupEmulator:android" to reconfigure Android settings',indent:1,prefix:"└─ ",color:"yellow"},"\nVerify Configuration:");// Add configuration details only if androidConfig is available
+if(androidConfig){troubleshootingItems.push({text:`Build Type: ${buildType}`,indent:1,prefix:"├─ ",color:"gray"},{text:`Android SDK Path: ${androidConfig.sdkPath||"Not configured"}`,indent:1,prefix:"├─ ",color:"gray"});if(buildType!=="release"){// Show device information if available
+if(targetDevice){troubleshootingItems.push({text:`Target Device: ${targetDevice.type==="physical"?`${targetDevice.model} (Physical)`:`${androidConfig.emulatorName} (Emulator)`}`,indent:1,prefix:"└─ ",color:"gray"});}else{troubleshootingItems.push({text:`Selected Emulator: ${androidConfig.emulatorName||"Not configured"}`,indent:1,prefix:"└─ ",color:"gray"});}}else{troubleshootingItems.push({text:`Output Path: ${androidConfig.outputPath||"build-output/"}`,indent:1,prefix:"└─ ",color:"gray"});}}else{troubleshootingItems.push({text:"Configuration could not be loaded",indent:1,prefix:"├─ ",color:"red"},{text:"Check if config/config.json exists and has valid Android configuration",indent:1,prefix:"└─ ",color:"red"});}progress.printTreeContent("Troubleshooting Guide",troubleshootingItems);}process.exit(1);}}// Execute the main build process
 buildAndroidApp();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "catalyst-core",
-    "version": "0.0.3-canary.7",
+    "version": "0.0.3-canary.8",
     "main": "index.js",
     "description": "Web framework that provides great performance out of the box",
     "bin": {

package/dist/native/androidProject/.idea/deviceManager.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="DeviceTable">
-    <option name="columnSorters">
-      <list>
-        <ColumnSorterState>
-          <option name="column" value="Name" />
-          <option name="order" value="ASCENDING" />
-        </ColumnSorterState>
-      </list>
-    </option>
-  </component>
-</project>