catalyst-core 0.0.3-canary.1 → 0.0.3-canary.10

package/README.md

@@ -9,14 +9,13 @@
 
 -   Overview
 -   Installation
-  
+
 ## Overview
 
 Catalyst offers a comprehensive suite of features designed for modern web development. It includes isomorphic rendering for optimal performance, an extendable server with full-stack capabilities, and configurable state management. The framework employs smart prefetching of data and chunks, allows easy configuration of global styles and layouts, and provides SEO optimization at both global and page levels.
 
 This version adds support for Universal app for both Android and iOS. Please checkout [Universal App Documentaion](https://catalyst.1mg.com/public_docs/content/Universal%20App/RunUniversalApp)
 
-
 ## Installation
 
 **System Requirements**
@@ -38,7 +37,7 @@ You will see some prompts to configure your application.
 cd <name-of-your-project> && npm run start
 ```
 
-The development server will start at ```http://localhost:3005```
+The development server will start at `http://localhost:3005`
 
 ## Documentation
 

package/babel.config.js

@@ -0,0 +1,32 @@
+module.exports = (api) => {
+    api.cache(true)
+
+    return {
+        presets: [
+            [
+                "@babel/preset-typescript",
+                {
+                    isTSX: true,
+                    allExtensions: true,
+                },
+            ],
+            [
+                "@babel/preset-env",
+                {
+                    targets: {
+                        node: "current",
+                    },
+                },
+            ],
+            ["@babel/preset-react", { runtime: "automatic" }],
+        ],
+        compact: true,
+        plugins: ["@loadable/babel-plugin"],
+        env: {
+            test: {
+                presets: ["@babel/preset-react"],
+            },
+        },
+        ignore: ["__TEST__"],
+    }
+}

package/bin/catalyst.js

@@ -8,9 +8,17 @@ const args = process.argv.slice(2)
 
 // Array of valid commands
 const validCommands = [
-    "build", "start", "serve", "devBuild", "devServe",
-    "buildApp", "buildApp:ios", "buildApp:android",
-    "setupEmulator", "setupEmulator:ios", "setupEmulator:android"
+    "build",
+    "start",
+    "serve",
+    "devBuild",
+    "devServe",
+    "buildApp",
+    "buildApp:ios",
+    "buildApp:android",
+    "setupEmulator",
+    "setupEmulator:ios",
+    "setupEmulator:android",
 ]
 
 // Map of platform-specific commands to their script paths
@@ -18,17 +26,16 @@ const platformScripts = {
     "setupEmulator:ios": "../dist/native/setupEmulatorIos.js",
     "setupEmulator:android": "../dist/native/androidSetup.js",
     "buildApp:ios": "../dist/native/buildAppIos.js",
-    "buildApp:android": "../dist/native/buildAppAndroid.js"
+    "buildApp:android": "../dist/native/buildAppAndroid.js",
 }
 
 // Helper to check if arg is a platform command
 const isPlatformCommand = (arg, prefix) => {
     if (!arg.startsWith(`${prefix}:`)) return false
-    const platform = arg.split(':')[1]
-    return ['ios', 'android'].includes(platform) || platform === undefined
+    const platform = arg.split(":")[1]
+    return ["ios", "android"].includes(platform) || platform === undefined
 }
 
-
 // Helper function to run a platform command
 const runPlatformCommand = (baseCommand, platform) => {
     const command = `${baseCommand}:${platform}`
@@ -42,7 +49,7 @@ const runPlatformCommand = (baseCommand, platform) => {
 
 // Helper function to run commands for all platforms
 const runAllPlatforms = (baseCommand) => {
-    const platforms = ['ios', 'android']
+    const platforms = ["ios", "android"]
     for (const platform of platforms) {
         const result = runPlatformCommand(baseCommand, platform)
         if (result.status !== 0) {
@@ -54,8 +61,14 @@ const runAllPlatforms = (baseCommand) => {
 }
 
 const scriptIndex = args.findIndex(
-    (x) => x === "build" || x === "start" || x === "serve" || x === "devBuild" || x === "devServe" || 
-    isPlatformCommand(x, 'buildApp') || isPlatformCommand(x, 'setupEmulator')
+    (x) =>
+        x === "build" ||
+        x === "start" ||
+        x === "serve" ||
+        x === "devBuild" ||
+        x === "devServe" ||
+        isPlatformCommand(x, "buildApp") ||
+        isPlatformCommand(x, "setupEmulator")
 )
 const script = scriptIndex === -1 ? args[0] : args[scriptIndex]
 const nodeArgs = scriptIndex > 0 ? args.slice(0, scriptIndex) : []
@@ -92,17 +105,17 @@ function handleProcessResult(result) {
         if (result.signal === "SIGKILL") {
             console.log(
                 "The build failed because the process exited too early. " +
-                "This probably means the system ran out of memory or someone called " +
-                "`kill -9` on the process."
+                    "This probably means the system ran out of memory or someone called " +
+                    "`kill -9` on the process."
             )
         } else if (result.signal === "SIGTERM") {
             console.log(
                 "The build failed because the process exited too early. " +
-                "Someone might have called `kill` or `killall`, or the system could " +
-                "be shutting down."
+                    "Someone might have called `kill` or `killall`, or the system could " +
+                    "be shutting down."
             )
         }
         process.exit(1)
     }
     process.exit(result.status)
-}
+}

package/changelog.md

@@ -1,36 +1,69 @@
 # Changelog
 
-## [0.0.3-canary.1] - 31-01-2025
+## [0.0.3-canary.10] - 2025-09-11
 
-### Changes
+-   **Sentry import bug fix**
+-   **Open telemetry SDK**
 
-# Native WebView Implementation and Cache Management Updates
+## [0.0.3-canary.9] - 2025-09-11
 
-## Overview
-This PR introduces native WebView implementations for both Android and iOS platforms, along with significant cache management improvements and bug fixes.
+-   **App name configuration**
+-   **Device Info API**
+-   **Access control configuration**
 
-## Changes
+## [0.0.3-canary.8] - 2025-01-06
 
-### New Features
-- Implemented native Android WebView with cache management functionality
-- Added iOS native WebView implementation with custom cache handling
-- Introduced new cache pattern management system
+-   **App icon configuration**
+-   **Splash screen integration**
+-   **Url Whitelisting**
 
-### Technical Implementation Details
-- Android:
-  - Added complete Android project structure with WebView implementation
-  - Implemented `WebCacheManager.kt` for handling cache operations
-  - Set up Gradle configuration and project dependencies
+## [0.0.3-canary.7] - 2025-01-06
 
-- iOS:
-  - Created iOS native WebView project with Swift
-  - Implemented `CacheManager.swift` and `ResourceURLProtocol.swift` for cache handling
-  - Added WebView navigation and view model components
+### 🚀 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
 
-### Other Changes
-- Enhanced terminal progress reporting
-- Updated documentation and README
+### 🐛 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
+
+### 🧪 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
+
+### 🔄 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
+
+### 🔗 Migration Notes
+
+-   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.1
+
+-   Target version: 0.0.3-canary.7

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

@@ -1,8 +1,19 @@
 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
+val keyAlias: String? by project.properties
+val keyPassword: String? by project.properties
 
 fun getLocalIpAddress(): String {
     return NetworkInterface.getNetworkInterfaces().toList()
@@ -18,35 +29,73 @@ plugins {
 }
 
 android {
-    namespace = "com.example.androidProject"
+    namespace = "io.yourname.androidproject"
     compileSdk = 34
 
     defaultConfig {
-        applicationId = "com.example.androidProject"
+        applicationId = "io.yourname.androidproject"
         minSdk = 24
         targetSdk = 34
         versionCode = 1
-        versionName = "1.0"
+        versionName = "1.1"
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         buildConfigField("String", "LOCAL_IP", "\"${getLocalIpAddress()}\"")
     }
 
+    // Add signing configuration for app bundle
+    signingConfigs {
+        create("release") {
+            // Make sure the keystore file exists before referencing it
+            val keystoreFile = file("../keystore/release-key.jks")
+            if (keystoreFile.exists()) {
+               storeFile = file("../keystore/release-key.jks")
+                storePassword = "test@123"
+                keyAlias = "release"
+                keyPassword = "test@123"
+            } else {
+                // Log a warning if the keystore doesn't exist yet
+                logger.warn("Keystore file not found at ${keystoreFile.absolutePath}. Run the generateKeystore task first.")
+            }
+        }
+    }
+
     buildTypes {
         debug {
             manifestPlaceholders += mapOf("allowCleartextTraffic" to true)
+            applicationIdSuffix = ".debug"
+            versionNameSuffix = "-debug"
             isMinifyEnabled = false
             buildConfigField("Boolean", "ALLOW_MIXED_CONTENT", "true")
             buildConfigField("String", "LOCAL_IP", "\"${getLocalIpAddress()}\"")
         }
         release {
             manifestPlaceholders += mapOf("allowCleartextTraffic" to false)
-            isMinifyEnabled = false
+            isMinifyEnabled = true
+            isShrinkResources = true
             proguardFiles(
                 getDefaultProguardFile("proguard-android-optimize.txt"),
                 "proguard-rules.pro"
             )
             buildConfigField("Boolean", "ALLOW_MIXED_CONTENT", "false")
             buildConfigField("String", "LOCAL_IP", "\"127.0.0.1\"")
+
+            // Only apply signing config if the keystore exists
+            if (file("../keystore/release-key.jks").exists()) {
+                signingConfig = signingConfigs.getByName("release")
+            }
+        }
+    }
+
+    // Configure App Bundle settings
+    bundle {
+        language {
+            enableSplit = true
+        }
+        density {
+            enableSplit = true
+        }
+        abi {
+            enableSplit = true
         }
     }
 
@@ -63,6 +112,23 @@ android {
         viewBinding = true
         buildConfig = true
     }
+
+    packaging {
+        resources {
+            excludes.add("**/route-manifest.json.gz")
+            excludes.add("**/route-manifest.json.br")
+            excludes.add("META-INF/LICENSE")
+            excludes.add("META-INF/NOTICE")
+            excludes.add("META-INF/INDEX.LIST")
+            excludes.add("META-INF/io.netty.versions.properties")
+        }
+    }
+
+    // Configure lint options
+    lint {
+        checkReleaseBuilds = true
+        abortOnError = true
+    }
 }
 
 dependencies {
@@ -75,6 +141,16 @@ 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")
+    implementation("io.ktor:ktor-server-netty:2.3.7")
+    implementation("io.ktor:ktor-server-content-negotiation:2.3.7")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
+    
+    // SLF4J simple logger for Ktor (optional, can be excluded if needed)
+    implementation("org.slf4j:slf4j-simple:2.0.9")
 }
 
 // Task to verify local IP
@@ -129,52 +205,130 @@ tasks.register("generateWebViewConfig") {
         }
 
         val configContent = configJsonFile.readText()
+        
+        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()
 
-        // Extract WEBVIEW_CONFIG section
-        val webviewConfigRegex = """"WEBVIEW_CONFIG"\s*:\s*\{([^}]*)\}""".toRegex()
-        val webviewConfigMatch = webviewConfigRegex.find(configContent)
-        val webviewConfigContent = webviewConfigMatch?.groupValues?.get(1)
+        // Set different IP based on build type
+        if (gradle.startParameter.taskNames.any { it.contains("Release") || it.contains("release") }) {
+            properties.setProperty("LOCAL_IP", "127.0.0.1") // Production
+            properties.setProperty("buildType", "release")
+            properties.setProperty("buildOptimisation", "true")
+        } else {
+            properties.setProperty("LOCAL_IP", getLocalIpAddress()) // Debug
+            properties.setProperty("buildType", "debug")
+            properties.setProperty("buildOptimisation", "false")
+        }
 
-        val properties = Properties()
-        properties.setProperty("LOCAL_IP", getLocalIpAddress())
-
-        // 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)
+        extractProperties(webviewConfig)
 
-        // 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)
-            }
+        // Set production-specific properties for release builds
+        if (gradle.startParameter.taskNames.any { it.contains("Release") || it.contains("release") }) {
+            properties.setProperty("PRODUCTION_URL", "https://yourwebapp.com") // Replace with your domain
+            properties.setProperty("apiBaseUrl", "https://api.yourdomain.com/") // Replace with your API URL
         }
 
         // Create the assets directory if it doesn't exist
         val assetsDir = File("${project.projectDir}/src/main/assets")
         if (!assetsDir.exists()) {
             assetsDir.mkdirs()
-            println("Created assets directory at ${assetsDir.absolutePath}")
         }
 
         // Write to properties file
         File(assetsDir, "webview_config.properties").outputStream().use {
             properties.store(it, "WebView Configuration")
         }
+    }
+}
+
+// Task to create key store if it doesn't exist
+// Add this task to your build.gradle.kts
+tasks.register("generateKeystore") {
+    doLast {
+        val keystoreDir = File(project.rootDir, "keystore")
+        if (!keystoreDir.exists()) {
+            keystoreDir.mkdirs()
+        }
 
-        println("WebView config generated at ${assetsDir.absolutePath}/webview_config.properties")
+        val keystoreFile = File(keystoreDir, "release-key.jks")
+        if (!keystoreFile.exists()) {
+            val storePass = project.properties["keystorePassword"] as? String ?: System.getenv("KEYSTORE_PASSWORD") ?: "android"
+            val keyPass = project.properties["keyPassword"] as? String ?: System.getenv("KEY_PASSWORD") ?: "android"
+            val alias = project.properties["keyAlias"] as? String ?: System.getenv("KEY_ALIAS") ?: "release"
+
+            exec {
+                commandLine = listOf(
+                    "keytool",
+                    "-genkey",
+                    "-v",
+                    "-keystore", keystoreFile.absolutePath,
+                    "-alias", alias,
+                    "-keyalg", "RSA",
+                    "-keysize", "2048",
+                    "-validity", "10000",
+                    "-storepass", storePass,
+                    "-keypass", keyPass,
+                    "-dname", "CN=YourCompany, OU=YourDepartment, O=YourOrganization, L=YourCity, ST=YourState, C=US"
+                )
+            }
+            println("Generated keystore at: ${keystoreFile.absolutePath}")
+        } else {
+            println("Keystore already exists at: ${keystoreFile.absolutePath}")
+        }
+    }
+}
+// Task to build app bundle
+tasks.register("createAppBundle") {
+    dependsOn("generateKeystore", "bundleRelease")
+    doLast {
+        println("""
+            =======================================================
+            App Bundle created successfully!
+            
+            Location: ${project.buildDir}/outputs/bundle/release/app-release.aab
+            
+            Next steps:
+            1. Test your bundle with: 
+               bundletool build-apks --bundle=app/build/outputs/bundle/release/app-release.aab --output=test.apks
+            
+            2. Upload to Play Console: https://play.google.com/console
+            =======================================================
+        """.trimIndent())
     }
 }

package/dist/native/androidProject/app/src/main/AndroidManifest.xml

@@ -3,26 +3,45 @@
     xmlns:tools="http://schemas.android.com/tools">
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.VIBRATE" />
+    <uses-feature android:name="android.hardware.camera" android:required="false" />
+    <queries>
+        <intent>
+            <action android:name="android.media.action.IMAGE_CAPTURE" />
+        </intent>
+    </queries>
     <application
-        android:usesCleartextTraffic="${allowCleartextTraffic}"
         android:allowBackup="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"
+        android:hardwareAccelerated="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.AndroidProject"
+        android:usesCleartextTraffic="${allowCleartextTraffic}"
         tools:targetApi="31">
         <activity
-            android:name=".MainActivity"
-            android:exported="true">
+            android:name="io.yourname.androidproject.MainActivity"
+            android:exported="true"
+            android:screenOrientation="portrait">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="io.yourname.androidproject.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
     </application>
 
 </manifest>