@appboxo/capacitor-boxo-sdk 0.0.2

package/CapacitorBoxoSdk.podspec

@@ -0,0 +1,18 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorBoxoSdk'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target  = '13.0'
+  s.dependency 'Capacitor'
+  s.dependency 'AppBoxoSDK', '1.5.4'
+  s.swift_version = '5.1'
+end

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapacitorBoxoSdk",
+    platforms: [.iOS(.v13)],
+    products: [
+        .library(
+            name: "CapacitorBoxoSdk",
+            targets: ["AppboxoPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", branch: "main")
+    ],
+    targets: [
+        .target(
+            name: "AppboxoPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/AppboxoPlugin"),
+        .testTarget(
+            name: "AppboxoPluginTests",
+            dependencies: ["AppboxoPlugin"],
+            path: "ios/Tests/AppboxoPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,240 @@
+# capacitor-boxo-sdk
+
+A Capacitor wrapper over Appboxo SDK for IOS and Android.
+
+## Install
+
+```bash
+npm install capacitor-boxo-sdk
+npx cap sync
+```
+
+## API
+
+<docgen-index>
+
+* [`setConfig(...)`](#setconfig)
+* [`openMiniapp(...)`](#openminiapp)
+* [`setAuthCode(...)`](#setauthcode)
+* [`closeMiniapp(...)`](#closeminiapp)
+* [`sendCustomEvent(...)`](#sendcustomevent)
+* [`sendPaymentEvent(...)`](#sendpaymentevent)
+* [`getMiniapps()`](#getminiapps)
+* [`hideMiniapps()`](#hideminiapps)
+* [`logout()`](#logout)
+* [Interfaces](#interfaces)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### setConfig(...)
+
+```typescript
+setConfig(options: ConfigOptions) => Promise<void>
+```
+
+Set global configs
+
+| Param         | Type                                                    |
+| ------------- | ------------------------------------------------------- |
+| **`options`** | <code><a href="#configoptions">ConfigOptions</a></code> |
+
+--------------------
+
+
+### openMiniapp(...)
+
+```typescript
+openMiniapp(options: OpenMiniappOptions) => Promise<void>
+```
+
+Open miniapp with options
+
+| Param         | Type                                                              |
+| ------------- | ----------------------------------------------------------------- |
+| **`options`** | <code><a href="#openminiappoptions">OpenMiniappOptions</a></code> |
+
+--------------------
+
+
+### setAuthCode(...)
+
+```typescript
+setAuthCode(options: { appId: string; authCode: string; }) => Promise<void>
+```
+
+get AuthCode from hostapp backend and send it to miniapp
+
+| Param         | Type                                              |
+| ------------- | ------------------------------------------------- |
+| **`options`** | <code>{ appId: string; authCode: string; }</code> |
+
+--------------------
+
+
+### closeMiniapp(...)
+
+```typescript
+closeMiniapp(options: { appId: string; }) => Promise<void>
+```
+
+close miniapp by appId
+
+| Param         | Type                            |
+| ------------- | ------------------------------- |
+| **`options`** | <code>{ appId: string; }</code> |
+
+--------------------
+
+
+### sendCustomEvent(...)
+
+```typescript
+sendCustomEvent(customEvent: CustomEvent) => Promise<void>
+```
+
+send custom event to miniapp
+
+| Param             | Type                                                |
+| ----------------- | --------------------------------------------------- |
+| **`customEvent`** | <code><a href="#customevent">CustomEvent</a></code> |
+
+--------------------
+
+
+### sendPaymentEvent(...)
+
+```typescript
+sendPaymentEvent(paymentEvent: PaymentEvent) => Promise<void>
+```
+
+send payment event to miniapp
+
+| Param              | Type                                                  |
+| ------------------ | ----------------------------------------------------- |
+| **`paymentEvent`** | <code><a href="#paymentevent">PaymentEvent</a></code> |
+
+--------------------
+
+
+### getMiniapps()
+
+```typescript
+getMiniapps() => Promise<MiniappListResult>
+```
+
+Get list of miniapps
+
+**Returns:** <code>Promise&lt;<a href="#miniapplistresult">MiniappListResult</a>&gt;</code>
+
+--------------------
+
+
+### hideMiniapps()
+
+```typescript
+hideMiniapps() => Promise<void>
+```
+
+Miniapp opens on a native screen. To show payment processing page need to hide miniapp screen.
+To use this function need to enable 'enableMultitaskMode: true' in Appboxo.setConfigs()
+
+--------------------
+
+
+### logout()
+
+```typescript
+logout() => Promise<void>
+```
+
+When host app user logs out, it is highly important to clear all miniapp storage data.
+
+--------------------
+
+
+### Interfaces
+
+
+#### ConfigOptions
+
+| Prop                      | Type                                       | Description                                                                              |
+| ------------------------- | ------------------------------------------ | ---------------------------------------------------------------------------------------- |
+| **`clientId`**            | <code>string</code>                        | your client id from dashboard                                                            |
+| **`userId`**              | <code>string</code>                        | hostapp userId, will be used for the Consent Management                                  |
+| **`sandboxMode`**         | <code>boolean</code>                       | switch to sandbox mode                                                                   |
+| **`enableMultitaskMode`** | <code>boolean</code>                       | Each miniapp appears as a task in the Recents screen. !It works only on android devices. |
+| **`theme`**               | <code>'light' \| 'dark' \| 'system'</code> | theme for splash screen and other native components used inside miniapp.                 |
+| **`isDebug`**             | <code>boolean</code>                       | enables webview debugging                                                                |
+| **`showPermissionsPage`** | <code>boolean</code>                       | use it to hide "Settings" from Miniapp menu                                              |
+| **`showClearCache`**      | <code>boolean</code>                       | use it to hide "Clear cache" from Miniapp menu                                           |
+
+
+#### OpenMiniappOptions
+
+| Prop                 | Type                                                  | Description                                                                                       |
+| -------------------- | ----------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| **`appId`**          | <code>string</code>                                   | miniapp id                                                                                        |
+| **`data`**           | <code>object</code>                                   | (optional) data as Map that is sent to miniapp                                                    |
+| **`theme`**          | <code>'light' \| 'dark' \| 'system'</code>            | (optional) miniapp theme "dark" \| "light" (by default is system theme)                           |
+| **`extraUrlParams`** | <code>object</code>                                   | (optional) extra query params to append to miniapp URL (like: http://miniapp-url.com/?param=test) |
+| **`urlSuffix`**      | <code>string</code>                                   | (optional) suffix to append to miniapp URL (like: http://miniapp-url.com/?param=test)             |
+| **`colors`**         | <code><a href="#coloroptions">ColorOptions</a></code> | (optional) provide colors to miniapp if miniapp supports                                          |
+| **`enableSplash`**   | <code>boolean</code>                                  | (optional) use to skip miniapp splash screen                                                      |
+
+
+#### ColorOptions
+
+| Prop                 | Type                |
+| -------------------- | ------------------- |
+| **`primaryColor`**   | <code>string</code> |
+| **`secondaryColor`** | <code>string</code> |
+| **`tertiaryColor`**  | <code>string</code> |
+
+
+#### CustomEvent
+
+| Prop            | Type                |
+| --------------- | ------------------- |
+| **`appId`**     | <code>string</code> |
+| **`requestId`** | <code>number</code> |
+| **`type`**      | <code>string</code> |
+| **`errorType`** | <code>string</code> |
+| **`payload`**   | <code>object</code> |
+
+
+#### PaymentEvent
+
+| Prop                   | Type                |
+| ---------------------- | ------------------- |
+| **`appId`**            | <code>string</code> |
+| **`transactionToken`** | <code>string</code> |
+| **`miniappOrderId`**   | <code>string</code> |
+| **`amount`**           | <code>number</code> |
+| **`currency`**         | <code>string</code> |
+| **`status`**           | <code>string</code> |
+| **`hostappOrderId`**   | <code>string</code> |
+| **`extraParams`**      | <code>object</code> |
+
+
+#### MiniappListResult
+
+| Prop           | Type                       |
+| -------------- | -------------------------- |
+| **`miniapps`** | <code>[MiniappData]</code> |
+| **`error`**    | <code>string</code>        |
+
+
+#### MiniappData
+
+| Prop              | Type                |
+| ----------------- | ------------------- |
+| **`appId`**       | <code>string</code> |
+| **`name`**        | <code>string</code> |
+| **`category`**    | <code>string</code> |
+| **`description`** | <code>string</code> |
+| **`logo`**        | <code>string</code> |
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,84 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.6.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.1.5'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.5.1'
+}
+
+buildscript {
+    ext {
+        kotlin_version = '1.9.22'
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.2.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace "io.boxo.sdk.capacitor"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 34
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 22
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 34
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+    kotlinOptions {
+        jvmTarget = '17'
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+rootProject.allprojects {
+    repositories {
+        maven { url "https://jitpack.io" }
+        jcenter()
+        maven {
+            url "https://maven.pkg.github.com/Appboxo/android-sdk-packages"
+            credentials {
+                username = "appboxoandroidsdk"
+                password = "\u0037\u0039\u0064\u0031\u0065\u0064\u0061\u0036\u0030\u0034\u0063\u0061\u0031\u0066\u0030\u0032\u0066\u0031\u0037\u0066\u0032\u0061\u0039\u0033\u0064\u0035\u0039\u0039\u0061\u0035\u0035\u0062\u0066\u0065\u0031\u0064\u0066\u0064\u0038\u0038"
+            }
+        }
+    }
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+    implementation project(':capacitor-android')
+    implementation('com.appboxo:sdk:1.5.7') {
+        exclude group: 'com.google.android.gms', module: 'play-services-location'
+    }
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/io/boxo/sdk/capacitor/AppboxoPlugin.kt

@@ -0,0 +1,322 @@
+package io.boxo.sdk.capacitor
+
+import android.os.Handler
+import android.os.Looper
+import com.appboxo.data.models.MiniappData
+import com.appboxo.js.params.CustomEvent
+import com.appboxo.js.params.PaymentData
+import com.appboxo.sdk.Appboxo
+import com.appboxo.sdk.Config
+import com.appboxo.sdk.Miniapp
+import com.appboxo.sdk.MiniappConfig
+import com.appboxo.sdk.MiniappListCallback
+import com.appboxo.ui.main.AppboxoActivity
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+
+@CapacitorPlugin(name = "Appboxo")
+class AppboxoPlugin : Plugin(), Miniapp.LifecycleListener,
+    Miniapp.CustomEventListener, Miniapp.AuthListener,
+    Miniapp.PaymentEventListener {
+
+    private var handler: Handler? = null
+
+    override fun load() {
+        super.load()
+        Appboxo.init(bridge.activity.application)
+        handler = Handler(Looper.getMainLooper())
+    }
+
+    @PluginMethod
+    fun setConfig(call: PluginCall) {
+        val clientId = call.getString("clientId")!!
+        val userId = call.getString("userId") ?: ""
+        val sandboxMode = call.getBoolean("sandboxMde", false)!!
+        val enableMultitaskMode = call.getBoolean("enableMultitaskMode", false)!!
+        val theme = call.getString("theme", "system")!!
+        val isDebug = call.getBoolean("isDebug", false)!!
+        val showPermissionsPage = call.getBoolean("showPermissionsPage", true)!!
+        val showClearCache = call.getBoolean("showClearCache", true)!!
+        val globalTheme: Config.Theme = when (theme) {
+            "light" -> Config.Theme.LIGHT
+            "dark" -> Config.Theme.DARK
+            else -> Config.Theme.SYSTEM
+        }
+        Appboxo
+            .setConfig(
+                Config.Builder()
+                    .setClientId(clientId)
+                    .setUserId(userId)
+                    .sandboxMode(sandboxMode)
+                    .multitaskMode(enableMultitaskMode)
+                    .setTheme(globalTheme)
+                    .permissionsPage(showPermissionsPage)
+                    .showClearCache(showClearCache)
+                    .debug(isDebug)
+                    .build()
+            )
+    }
+
+    @PluginMethod
+    fun openMiniapp(call: PluginCall) {
+        val appId = call.getString("appId")!!
+        val data = call.getObject("data")
+        val theme = call.getString("theme")
+        val extraUrlParams = call.getObject("extraUrlParams")
+        val urlSuffix = call.getString("urlSuffix")
+        val colors = call.getObject("colors")
+        val enableSplash = call.getBoolean("enableSplash")
+        val miniapp: Miniapp = Appboxo.getMiniapp(appId)
+            .setCustomEventListener(this)
+            .setPaymentEventListener(this)
+            .setAuthListener(this)
+            .setLifecycleListener(this)
+        if (data != null) miniapp.setData(data.toMap())
+        val configBuilder = MiniappConfig.Builder()
+        if (theme != null) {
+            val miniappTheme: Config.Theme? = when (theme) {
+                "light" -> Config.Theme.LIGHT
+                "dark" -> Config.Theme.DARK
+                "system" -> Config.Theme.SYSTEM
+                else -> null
+            }
+            if (miniappTheme != null) {
+                configBuilder.setTheme(miniappTheme)
+            }
+        }
+        if (extraUrlParams != null) {
+            val map: Map<String, Any> = extraUrlParams.toMap()
+            val stringMap: MutableMap<String, String> = HashMap()
+            for ((key, value) in map) stringMap[key] = value.toString()
+            configBuilder.setExtraUrlParams(stringMap)
+        }
+        urlSuffix?.also { suffix -> configBuilder.setUrlSuffix(suffix) }
+        if (colors != null) {
+            configBuilder.setColors(
+                colors.getString("primaryColor") ?: "",
+                colors.getString("secondaryColor") ?: "",
+                colors.getString("tertiaryColor") ?: "",
+            )
+        }
+        if (enableSplash != null)
+            configBuilder.enableSplash(enableSplash)
+        miniapp.setConfig(configBuilder.build())
+        miniapp.open(bridge.activity)
+    }
+
+    @PluginMethod
+    fun setAuthCode(call: PluginCall) {
+        val appId = call.getString("appId")!!
+        val authCode = call.getString("authCode")!!
+        Appboxo.getMiniapp(appId)
+            .setAuthCode(authCode)
+    }
+
+    @PluginMethod
+    fun closeMiniapp(call: PluginCall) {
+        val appId = call.getString("appId")!!
+        handler?.post { Appboxo.getExistingMiniapp(appId)?.close() }
+    }
+
+    override fun handle(
+        miniAppActivity: AppboxoActivity,
+        miniapp: Miniapp,
+        customEvent: CustomEvent
+    ) {
+        val params = JSObject()
+        params.put("appId", miniapp.appId)
+        try {
+            params.put("requestId", customEvent.requestId ?: 0)
+            params.put("type", customEvent.type)
+            params.put("errorType", customEvent.errorType)
+            params.put("payload", customEvent.payload)
+            sendEvent(CUSTOM_EVENTS_EVENT_NAME, params)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    override fun onLaunch(miniapp: Miniapp) {
+        val params = JSObject()
+        params.put("appId", miniapp.appId)
+        params.put("lifecycle", "onLaunch")
+        sendEvent(MINIAPP_LIFECYCLE_EVENT_NAME, params)
+    }
+
+    override fun onResume(miniapp: Miniapp) {
+        val params = JSObject()
+        params.put("appId", miniapp.appId)
+        params.put("lifecycle", "onResume")
+        sendEvent(MINIAPP_LIFECYCLE_EVENT_NAME, params)
+    }
+
+    override fun onPause(miniapp: Miniapp) {
+        val params = JSObject()
+        params.put("appId", miniapp.appId)
+        params.put("lifecycle", "onPause")
+        sendEvent(MINIAPP_LIFECYCLE_EVENT_NAME, params)
+    }
+
+    override fun onClose(miniapp: Miniapp) {
+        val params = JSObject()
+        params.put("appId", miniapp.appId)
+        params.put("lifecycle", "onClose")
+        sendEvent(MINIAPP_LIFECYCLE_EVENT_NAME, params)
+    }
+
+    override fun onError(miniapp: Miniapp, message: String) {
+        val params = JSObject()
+        params.put("appId", miniapp.appId)
+        params.put("lifecycle", "onError")
+        params.put("error", message)
+        sendEvent(MINIAPP_LIFECYCLE_EVENT_NAME, params)
+    }
+
+    override fun onUserInteraction(miniapp: Miniapp) {
+        val params = JSObject()
+        params.put("appId", miniapp.appId)
+        params.put("lifecycle", "onUserInteraction")
+        sendEvent(MINIAPP_LIFECYCLE_EVENT_NAME, params)
+    }
+
+    override fun onAuth(appboxoActivity: AppboxoActivity, miniapp: Miniapp) {
+        val params = JSObject()
+        params.put("appId", miniapp.appId)
+        params.put("lifecycle", "onAuth")
+        sendEvent(MINIAPP_LIFECYCLE_EVENT_NAME, params)
+    }
+
+    @PluginMethod
+    fun sendCustomEvent(call: PluginCall) {
+        try {
+            val appId: String = call.getString("appId")!!
+            val event = CustomEvent(
+                call.getInt("requestId"),
+                call.getString("type")!!,
+                call.getString("errorType"),
+                call.getObject("payload")?.toMap() ?: emptyMap()
+            )
+            handler?.post { Appboxo.getExistingMiniapp(appId)?.sendEvent(event) }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    @PluginMethod
+    fun sendPaymentEvent(call: PluginCall) {
+        try {
+            val appId: String = call.getString("appId")!!
+            val data = PaymentData(
+                call.getString("transactionToken") ?: "",
+                call.getString("miniappOrderId") ?: "",
+                call.getDouble("amount") ?: 0.0,
+                call.getString("currency") ?: "",
+                call.getString("status") ?: "",
+                call.getString("hostappOrderId") ?: "",
+                call.getObject("extraParams")?.toMap()
+            )
+            handler?.post { Appboxo.getExistingMiniapp(appId)?.sendPaymentResult(data) }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    @PluginMethod
+    fun getMiniapps(call: PluginCall) {
+        Appboxo.getMiniapps(object : MiniappListCallback {
+            override fun onSuccess(miniapps: List<MiniappData>) {
+                try {
+                    val list = JSArray()
+                    for (i in miniapps.indices) {
+                        val miniappData: MiniappData = miniapps[i]
+                        val data = JSObject()
+                        data.put("appId", miniappData.appId)
+                        data.put("name", miniappData.name)
+                        data.put("category", miniappData.category)
+                        data.put("logo", miniappData.logo)
+                        data.put("description", miniappData.description)
+                        list.put(data)
+                    }
+                    val params = JSObject()
+                    params.put("miniapps", list)
+                    call.resolve(params)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+
+            override fun onFailure(e: Exception) {
+                val result = JSObject()
+                result.put("error", e.message)
+                call.resolve(result)
+            }
+        })
+    }
+
+    @PluginMethod
+    fun hideMiniapps(call: PluginCall) {
+        Appboxo.hideMiniapps()
+    }
+
+    @PluginMethod
+    fun logout(call: PluginCall) {
+        Appboxo.logout()
+    }
+
+    private fun sendEvent(name: String, data: JSObject) {
+        notifyListeners(name, data)
+    }
+
+    override fun handle(
+        miniAppActivity: AppboxoActivity,
+        miniapp: Miniapp,
+        paymentData: PaymentData
+    ) {
+        val params = JSObject()
+        params.put("appId", miniapp.appId)
+        try {
+            params.put("transactionToken", paymentData.transactionToken)
+            params.put("miniappOrderId", paymentData.miniappOrderId)
+            params.put("amount", paymentData.amount)
+            params.put("currency", paymentData.currency)
+            params.put("status", paymentData.status)
+            params.put("hostappOrderId", paymentData.hostappOrderId)
+            if (paymentData.extraParams != null) {
+                params.put("extraParams", paymentData.extraParams)
+            }
+            sendEvent(PAYMENT_EVENTS_EVENT_NAME, params)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    companion object {
+        private const val CUSTOM_EVENTS_EVENT_NAME = "custom_event"
+        private const val PAYMENT_EVENTS_EVENT_NAME = "payment_event"
+        private const val MINIAPP_LIFECYCLE_EVENT_NAME = "miniapp_lifecycle"
+
+        fun JSObject.toMap(): Map<String, Any> {
+            val map: MutableMap<String, Any> = HashMap()
+            val iterator: Iterator<String> = this.keys()
+
+            while (iterator.hasNext()) {
+                val key = iterator.next()
+                var value: Any = this.get(key)
+
+                if (value is JSObject) {
+                    value = value.toMap()
+                }
+                if (value is JSArray) {
+                    value = value.toList<Any>()
+                }
+                map[key] = value
+            }
+
+            return map
+        }
+    }
+}