catalyst-core-internal 0.0.1-beta.50 → 0.0.1-beta.52

package/babel.config.js

@@ -0,0 +1,30 @@
+module.exports = (api) => {
+    api.cache(true)
+
+    const EXPERIMENTS = JSON.parse(process.env.EXPERIMENTS || "{}")
+
+    return {
+        presets: [
+            [
+                "@babel/preset-env",
+                {
+                    targets: {
+                        node: "current",
+                    },
+                },
+            ],
+            "@babel/preset-react",
+        ],
+        compact: true,
+        plugins: [
+            ...(EXPERIMENTS?.ENABLE_COMPILER ? [["babel-plugin-react-compiler", { target: "18" }]] : []),
+            "@loadable/babel-plugin",
+        ],
+        env: {
+            test: {
+                presets: ["@babel/preset-react"],
+            },
+        },
+        ignore: ["__TEST__"],
+    }
+}

package/changelog.md

@@ -1,6 +1,12 @@
 # Changelog
 
-## [0.0.1-canary.0] - 02-07-2024
+## [0.0.1-beta.9] - 13-12-2024
+
+### Changes
+
+-   Update @tata1mg/router's version to 0.0.1-beta.6.
+
+## [0.0.1-beta.8] - 09-12-2024
 
 ### Changes
 

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

@@ -0,0 +1,180 @@
+import java.net.NetworkInterface
+import java.io.File
+import java.util.Properties
+
+val configPath: String? by project.properties
+
+fun getLocalIpAddress(): String {
+    return NetworkInterface.getNetworkInterfaces().toList()
+        .flatMap { it.inetAddresses.toList() }
+        .filter { !it.isLoopbackAddress && it.hostAddress.indexOf(':') == -1 }
+        .map { it.hostAddress }
+        .firstOrNull() ?: "127.0.0.1"
+}
+
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.jetbrains.kotlin.android)
+}
+
+android {
+    namespace = "com.example.androidProject"
+    compileSdk = 34
+
+    defaultConfig {
+        applicationId = "com.example.androidProject"
+        minSdk = 24
+        targetSdk = 34
+        versionCode = 1
+        versionName = "1.0"
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        buildConfigField("String", "LOCAL_IP", "\"${getLocalIpAddress()}\"")
+    }
+
+    buildTypes {
+        debug {
+            manifestPlaceholders += mapOf("allowCleartextTraffic" to true)
+            isMinifyEnabled = false
+            buildConfigField("Boolean", "ALLOW_MIXED_CONTENT", "true")
+            buildConfigField("String", "LOCAL_IP", "\"${getLocalIpAddress()}\"")
+        }
+        release {
+            manifestPlaceholders += mapOf("allowCleartextTraffic" to false)
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+            buildConfigField("Boolean", "ALLOW_MIXED_CONTENT", "false")
+            buildConfigField("String", "LOCAL_IP", "\"127.0.0.1\"")
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+
+    buildFeatures {
+        viewBinding = true
+        buildConfig = true
+    }
+}
+
+dependencies {
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.appcompat)
+    implementation(libs.material)
+    implementation(libs.androidx.constraintlayout)
+    testImplementation(libs.junit)
+    androidTestImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+    implementation("androidx.webkit:webkit:1.12.1")
+    implementation("org.json:json:20231013")
+}
+
+// Task to verify local IP
+tasks.register("printLocalIp") {
+    doLast {
+        println("Local IP Address: ${getLocalIpAddress()}")
+    }
+}
+
+tasks.register("updateSdkPath") {
+    doLast {
+        val sdkPath: String? by project.properties
+
+        if (sdkPath == null) {
+            throw GradleException(
+                """
+                SDK path not provided!
+                Please provide the SDK path using -PsdkPath=/path/to/sdk
+                Example: ./gradlew updateSdkPath -PsdkPath=/path/to/android/sdk
+                """.trimIndent()
+            )
+        }
+
+        val localProperties = File(project.rootDir, "local.properties")
+        val properties = Properties()
+
+        if (localProperties.exists()) {
+            properties.load(localProperties.inputStream())
+        }
+
+        properties.setProperty("sdk.dir", sdkPath)
+        properties.store(localProperties.outputStream(), "Updated SDK Path")
+
+        println("Updated SDK path to: $sdkPath")
+    }
+}
+
+// Task to generate WebView config
+tasks.register("generateWebViewConfig") {
+    doLast {
+        val configJsonPath = configPath ?: throw GradleException(
+            """
+            Config path not provided! 
+            Please provide the config path using -PconfigPath=/path/to/your/config.json
+            Example: ./gradlew generateWebViewConfig -PconfigPath=/path/to/your/config.json
+            """.trimIndent()
+        )
+
+        val configJsonFile = File(configJsonPath)
+        if (!configJsonFile.exists()) {
+            throw GradleException("Config file not found at: $configJsonPath")
+        }
+
+        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 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)
+                }
+            }
+        }
+
+        // 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)
+            }
+        }
+
+        // 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")
+        }
+
+        println("WebView config generated at ${assetsDir.absolutePath}/webview_config.properties")
+    }
+}

package/dist/native/androidProject/app/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

package/dist/native/androidProject/app/src/androidTest/java/com/example/myapplication/ExampleInstrumentedTest.kt

@@ -0,0 +1,24 @@
+package com.example.myapplication
+
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.ext.junit.runners.AndroidJUnit4
+
+import org.junit.Test
+import org.junit.runner.RunWith
+
+import org.junit.Assert.*
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+@RunWith(AndroidJUnit4::class)
+class ExampleInstrumentedTest {
+    @Test
+    fun useAppContext() {
+        // Context of the app under test.
+        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
+        assertEquals("com.example.myapplication", appContext.packageName)
+    }
+}

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

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <application
+        android:usesCleartextTraffic="${allowCleartextTraffic}"
+        android:allowBackup="true"
+        android:dataExtractionRules="@xml/data_extraction_rules"
+        android:fullBackupContent="@xml/backup_rules"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.AndroidProject"
+        tools:targetApi="31">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

package/dist/native/androidProject/app/src/main/java/com/example/myapplication/MainActivity.kt

@@ -0,0 +1,278 @@
+package com.example.androidProject
+
+import android.annotation.SuppressLint
+import android.graphics.Bitmap
+import android.os.Bundle
+import android.util.Log
+import android.view.View
+import android.webkit.*
+import androidx.appcompat.app.AppCompatActivity
+import androidx.webkit.WebViewAssetLoader
+import java.util.Properties
+import com.example.androidProject.databinding.ActivityMainBinding
+import com.example.myapplication.WebCacheManager
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.runBlocking
+import org.json.JSONObject
+import java.net.URL                 
+import java.net.HttpURLConnection
+
+class MainActivity : AppCompatActivity(), CoroutineScope by MainScope() {
+
+    private val TAG = "WebViewDebug"
+    private lateinit var binding: ActivityMainBinding
+    private lateinit var myWebView: WebView
+    private lateinit var cacheManager: WebCacheManager
+    private var buildType: String = "debug"  // Default to debug
+    private var cachePatterns: List<String> = emptyList()
+
+    data class AndroidConfig(
+        val buildType: String = "debug",
+        val cachePattern: String = "",
+        val emulatorName: String = "",
+        val sdkPath: String = ""
+    )
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        val properties = Properties()
+        assets.open("webview_config.properties").use {
+            properties.load(it)
+        }
+
+        // Parse android config from JSON string
+        val androidConfigJson = properties.getProperty("android", "{}")
+        val androidConfig = try {
+            val jsonObject = JSONObject(androidConfigJson)
+            AndroidConfig(
+                buildType = jsonObject.optString("buildType", "debug"),
+                cachePattern = jsonObject.optString("cachePattern", ""),
+                emulatorName = jsonObject.optString("emulatorName", ""),
+                sdkPath = jsonObject.optString("sdkPath", "")
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Error parsing android config", e)
+            AndroidConfig()
+        }
+        Log.d(TAG, "android config parsed: $androidConfig")
+        buildType = androidConfig.buildType
+        cachePatterns = androidConfig.cachePattern
+            .split(",")
+            .map { it.trim() }
+            .filter { it.isNotEmpty() }
+
+        Log.d(TAG, "Build type: $buildType")
+        Log.d(TAG, "Cache Pattern: $cachePatterns ")
+
+        binding = ActivityMainBinding.inflate(layoutInflater)
+        supportActionBar?.hide()
+        setContentView(binding.root)
+
+        cacheManager = WebCacheManager(applicationContext)
+
+        // Clean up expired cache entries
+        launch(Dispatchers.IO) {
+            cacheManager.cleanup()
+        }
+
+        myWebView = binding.webview
+
+        // Clear any existing WebView data if this is a fresh start
+        if (savedInstanceState == null) {
+            myWebView.clearCache(false) // false means we keep files marked as "cache-control: no-cache"
+            myWebView.clearHistory()
+        } else {
+            myWebView.restoreState(savedInstanceState)
+        }
+
+        setupWebView(properties)
+
+        val local_ip = properties.getProperty("LOCAL_IP" , "localhost")
+        val port = properties.getProperty("port" , "3005")
+        val loadUrl = "http://$local_ip:$port"
+        makeRequest(loadUrl)
+    }
+
+    private fun shouldCacheUrl(url: String): Boolean {
+        // If no patterns specified, don't cache anything
+        if (cachePatterns.isEmpty()) return false
+
+        // Convert the wildcard pattern to a regex pattern
+        fun String.wildcardToRegex(): String {
+            return this.replace(".", "\\.")  // Escape dots
+                .replace("*", ".*")   // Convert * to .*
+                .let { "^$it$" }      // Anchor pattern
+        }
+
+        // Check if URL matches any of the patterns
+        return cachePatterns.any { pattern ->
+            val regex = pattern.wildcardToRegex().toRegex(RegexOption.IGNORE_CASE)
+            regex.matches(url) || url.endsWith(pattern.removePrefix("*"))
+        }
+    }
+
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+        myWebView.saveState(outState)
+    }
+
+    @SuppressLint("SetJavaScriptEnabled")
+    private fun setupWebView(properties: Properties) {
+        myWebView.settings.apply {
+            javaScriptEnabled = true
+            loadsImagesAutomatically = true
+            mixedContentMode = if (BuildConfig.ALLOW_MIXED_CONTENT) {
+                WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
+            } else {
+                WebSettings.MIXED_CONTENT_NEVER_ALLOW
+            }
+
+            // Enable standard caching
+            cacheMode = WebSettings.LOAD_DEFAULT // This will use both RAM and disk cache
+            databaseEnabled = true
+            domStorageEnabled = true
+
+            // Enable file access
+            allowFileAccess = true
+            allowContentAccess = true
+        }
+
+        myWebView.webViewClient = object : WebViewClient() {
+
+            override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {
+                request?.url?.let { url ->
+                    if (url.scheme in listOf("http", "https")) {
+                        view?.loadUrl(url.toString())
+                        return true
+                    }
+                }
+                return false
+            }
+
+            override fun shouldInterceptRequest(
+                view: WebView,
+                request: WebResourceRequest
+            ): WebResourceResponse? {
+                val originalUrl = request.url.toString()
+                Log.d(TAG, "Intercepting request for: $originalUrl")
+
+                if ( buildType == "debug" || request.method != "GET") {
+                    return null
+                }
+
+                // Check if URL matches patterns
+                if (!shouldCacheUrl(originalUrl)) {
+                    Log.d(TAG, "URL doesn't match cache patterns, skipping cache: $originalUrl")
+                    return null
+                }
+
+                return runBlocking {
+                    try {
+                        // Add cache control headers
+                        val headers = request.requestHeaders.toMutableMap().apply {
+                            if (!containsKey("Cache-Control")) {
+                                put("Cache-Control", "max-age=86400") // 24 hours
+                            }
+                            if (!containsKey("Pragma")) {
+                                put("Pragma", "cache")
+                            }
+                        }
+
+                        // Try to get from cache first
+                        var response = cacheManager.getCachedResponse(originalUrl, headers)
+
+                        if (response != null) {
+                            Log.d(TAG, "📱 Serving from cache: $originalUrl")
+                            response
+                        } else {
+                            Log.d(TAG, "Cache Manager unable to return response : $originalUrl")
+                            null
+                        }
+                    } catch (e: Exception) {
+                        Log.e(TAG, "❌ Error processing request for URL: $originalUrl", e)
+                        e.printStackTrace()
+                        null
+                    }
+                }
+            }
+
+            override fun onPageStarted(view: WebView?, url: String?, favicon: Bitmap?) {
+                super.onPageStarted(view, url, favicon)
+                binding.progress.visibility = View.VISIBLE
+                Log.d(TAG, "⏳ Page started loading: $url")
+            }
+
+            override fun onPageFinished(view: WebView?, url: String?) {
+                binding.progress.visibility = View.GONE
+                Log.d(TAG, "✅ Page finished loading: $url")
+                // Save to WebView's back/forward list
+                view?.clearHistory()
+                view?.saveState(Bundle())
+                super.onPageFinished(view, url)
+            }
+
+            override fun onReceivedError(view: WebView?, request: WebResourceRequest?, error: WebResourceError?) {
+                error?.let {
+                    Log.e(TAG, "❌ Error loading ${request?.url}: ${it.errorCode} ${it.description}")
+                }
+                super.onReceivedError(view, request, error)
+            }
+        }
+
+        myWebView.webChromeClient = object : WebChromeClient() {
+            override fun onProgressChanged(view: WebView, progress: Int) {
+                binding.progress.progress = progress
+                if (progress == 100) {
+                    binding.progress.visibility = View.GONE
+                }
+            }
+
+            override fun onConsoleMessage(consoleMessage: ConsoleMessage?): Boolean {
+                Log.d(TAG, "Console: ${consoleMessage?.message()} -- From line ${consoleMessage?.lineNumber()} of ${consoleMessage?.sourceId()}")
+                return true
+            }
+        }
+
+        WebView.setWebContentsDebuggingEnabled(true)
+    }
+
+    private fun makeRequest(url: String?) {
+        binding.webview.scrollBarStyle = View.SCROLLBARS_INSIDE_OVERLAY
+        url?.let { myWebView.loadUrl(it) }
+    }
+
+    override fun onBackPressed() {
+        if (myWebView.canGoBack()) {
+            myWebView.goBack()
+        } else {
+            super.onBackPressed()
+        }
+    }
+
+    override fun onPause() {
+        super.onPause()
+        myWebView.onPause()
+    }
+
+    override fun onResume() {
+        super.onResume()
+        myWebView.onResume()
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        myWebView.destroy()
+    }
+
+//    external fun stringFromJNI(): String
+
+//    companion object {
+//        init {
+//            System.loadLibrary("native-lib")
+//        }
+//    }
+}