catalyst-core 0.0.2-canary.0 → 0.0.3-canary.1

package/README.md

@@ -1,146 +1,44 @@
-# Catalyst
-
-Frontend framework with server rendering support for web applications.
+<div align="center">
+ <picture>
+ <source media="(prefers-color-scheme: dark)" srcset="https://onemg.gumlet.io/staging/7ee66dfb-b5fb-4fbe-8dea-789685e45f7a.svg">
+ <img alt="Catalyst logo" src="https://onemg.gumlet.io/staging/2fdb0975-8f51-4fd1-bd7d-6375d793f581.svg" height="128">
+ </picture>
+</div>
 
 ## Table of Contents
 
 -   Overview
 -   Installation
--   Data Fetching with Catalyst
-    -   serverFetcher
-    -   clientFetcher
-    -   refetch (for data revalidation)
--   State Management
-
+  
 ## Overview
 
-This package provides a way to proxy your request through your server. It allows you to cache your incoming request to improve your server response time.
+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**
 
 -   Node version 20.4.0 or later
--   macOS and Linux are supported
+-   Compatible with **macOS** and **Linux**
 
 **Automatic Installation**
 
--   Run the following commands in the directory where you want to set up the Catalyst app.
+Run the following commands in the directory where you want to set up the Catalyst app:
 
-```js
+```bash
 npx create-catalyst-app@latest
 ```
 
-If successful, you will see the following prompts in your terminal.
-
--   Enter the name of your Catalyst application.
--   Choose state management.
--   Once packages are installed,start the development server by running the following command.
+You will see some prompts to configure your application.
 
-```js
-cd project-name && npm run start
+```bash
+cd <name-of-your-project> && npm run start
 ```
 
--   Navigate to http://localhost:3005
-
-The dev server should be running now.
-
-Visit our official documentation:
-https://catalyst.1mg.com/public_docs/content/installation
-
-## Data Fetching with Catalyst
-
-we have serverFetcher function for fetching with SSR and clientFetcher function for fetching during client side rendering and navigations.
-
-**serverFetcher**
-
-server fetcher will get request, request params, search params and store (if project is setup with redux or rtk) as arguments. We can declare it as an async function and use await for fetching or use then chaining for data fetching.
-
-if server fetcher is called for a route then client fetcher will not be called for that route, unless called with refetch.
-
-```js
-Home.serverFetcher = async ({ req, params, searchParams }, { store }) => {
-    store.dispatch(someAction())
-    const res = await fetch("some_url")
-    const json = await res.json()
-    return json
-}
-```
-
-data returned from fetcher function will be accessible through useCurrentRouteData() hook provided by router.
-
-```js
-const [data, error, isFetched] = useCurrentRouteData()
-```
-
-error and loading state would be handled by router.
-
-**clientFetcher**
-
-client fetcher would be called on client side rendering and client side navigations. `store` would be available as a param in client side for dispatching redux/rtk actions.
-
-```js
-Home.clientFetcher = async ({ route, location, params, searchParams, navigate }, { store }) => {
-    store.dispatch(someAction())
-    const res = await fetch("some_url")
-    const json = await res.json()
-    return json
-}
-```
-
-data returned from client fetcher function will be accessible through useCurrentRouteData() hook provided by router (hook for data access through client is same).
-
-```js
-const [data, error, isFetched] = useCurrentRouteData()
-```
-
-**refetch (for data revalidation)**
-
-refetch function can be used were we need to execute clientFetcher based on some condition(such as for infinite scroll or some state change inside container or onClick.)
-
-We can pass arguments in refetch function which would
-
-```js
-const [data,error,isFetched,refetch] = useCurrentRouteData()
-
-useEffect(()=>{
-  refetch({refetchArgument:some_value})
-},[arg])
-
-clientFetcher = ({},{refetchArgument}) => {
-
-  const res = await api_call // refetchArg can be used as a param in api call
-  return res
-}
-
-```
-
-## State Management
-
-state management wrappers are defined in stateProvider.js file
-
-store can be configured by manipulating store/index.js as per user requirements (custom middlewares etc can be added in this way.
-
-initial state and request object would be provided in createStore function which will be called on server and client, we use the params to add additional arguments and middlewares in redux store.
-
-```js
-const configureStore = (initialState, cookies, requestObj, customHeaders) => {
-    const api = fetchInstance
-    const store = createStore({
-        reducer: rootReducer,
-        middleware: (getDefaultMiddleware) =>
-            getDefaultMiddleware({
-                thunk: {
-                    extraArgument: { api },
-                },
-            }),
-        preloadedState: initialState,
-    })
-    return store
-}
-
-export default configureStore
-```
+The development server will start at ```http://localhost:3005```
 
 ## Documentation
 

package/babel.config.json

@@ -11,6 +11,7 @@
         "@babel/preset-react"
     ],
     "compact": true,
+    "plugins": ["@loadable/babel-plugin"],
     "env": {
         "test": {
             "presets": ["@babel/preset-react"]

package/bin/catalyst.js

@@ -5,34 +5,104 @@ process.on("unhandledRejection", (err) => {
 })
 const { spawnSync } = require("node:child_process")
 const args = process.argv.slice(2)
-const scriptIndex = args.findIndex(
-    (x) => x === "build" || x === "start" || x === "serve" || x === "devBuild" || x === "devServe"
-)
-const script = scriptIndex === -1 ? args[0] : args[scriptIndex]
-const nodeArgs = scriptIndex > 0 ? args.slice(0, scriptIndex) : []
-if (["build", "start", "serve", "devBuild", "devServe"].includes(script)) {
+
+// Array of valid commands
+const validCommands = [
+    "build", "start", "serve", "devBuild", "devServe",
+    "buildApp", "buildApp:ios", "buildApp:android",
+    "setupEmulator", "setupEmulator:ios", "setupEmulator:android"
+]
+
+// Map of platform-specific commands to their script paths
+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"
+}
+
+// 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
+}
+
+
+// Helper function to run a platform command
+const runPlatformCommand = (baseCommand, platform) => {
+    const command = `${baseCommand}:${platform}`
     const result = spawnSync(
         process.execPath,
-        nodeArgs.concat(require.resolve("../dist/scripts/" + script)).concat(args.slice(scriptIndex + 1)),
+        nodeArgs.concat(require.resolve(platformScripts[command])).concat(args.slice(scriptIndex + 1)),
         { stdio: "inherit" }
     )
+    return result
+}
+
+// Helper function to run commands for all platforms
+const runAllPlatforms = (baseCommand) => {
+    const platforms = ['ios', 'android']
+    for (const platform of platforms) {
+        const result = runPlatformCommand(baseCommand, platform)
+        if (result.status !== 0) {
+            handleProcessResult(result)
+            return
+        }
+    }
+    process.exit(0)
+}
+
+const scriptIndex = args.findIndex(
+    (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) : []
+
+if (validCommands.includes(script)) {
+    // Handle platform-specific or combined commands
+    if (script === "buildApp" || script === "setupEmulator") {
+        // Run for all platforms if no specific platform is specified
+        runAllPlatforms(script)
+    } else if (script in platformScripts) {
+        // Run for specific platform
+        const result = spawnSync(
+            process.execPath,
+            nodeArgs.concat(require.resolve(platformScripts[script])).concat(args.slice(scriptIndex + 1)),
+            { stdio: "inherit" }
+        )
+        handleProcessResult(result)
+    } else {
+        // Original commands
+        const result = spawnSync(
+            process.execPath,
+            nodeArgs.concat(require.resolve("../dist/scripts/" + script)).concat(args.slice(scriptIndex + 1)),
+            { stdio: "inherit" }
+        )
+        handleProcessResult(result)
+    }
+} else {
+    console.log('Unknown script "' + script + '".')
+}
+
+// Helper function to handle process results
+function handleProcessResult(result) {
     if (result.signal) {
         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)
-} else {
-    console.log('Unknown script "' + script + '".')
-}
+}

package/changelog.md

@@ -1,18 +1,36 @@
 # Changelog
 
-## [0.0.1-beta.6] - 28-06-2024
+## [0.0.3-canary.1] - 31-01-2025
 
 ### Changes
 
--   Moved router, scripts, server and webpack directories present in root directoy to dist folder
--   Removed dependency from user defined module aliases (user can change any module alias without breaking catalyst) 
--   Module aliases defined for catalyst
--   Added exports inside package.json for tree shakeable support for logger, caching and ClientRouter.js
--   Hidden unnecessary files from published package: 
-    .prettierrc.json
-    .eslintrc
-    .eslintignore
-    /.husky 
-    /.github
-    commitlint.config.js
-    tsconfig.json
+# Native WebView Implementation and Cache Management Updates
+
+## Overview
+This PR introduces native WebView implementations for both Android and iOS platforms, along with significant cache management improvements and bug fixes.
+
+## Changes
+
+### 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
+
+### 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
+
+- iOS:
+  - Created iOS native WebView project with Swift
+  - Implemented `CacheManager.swift` and `ResourceURLProtocol.swift` for cache handling
+  - Added WebView navigation and view model components
+
+
+### Other Changes
+- Enhanced terminal progress reporting
+- Updated documentation and README
+
+## Version
+- Target version: 0.0.3-canary.1

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>