@algorandfoundation/react-native-passkey-autofill 0.0.1 → 1.0.0-canary.10

package/android/src/main/java/co/algorand/passkeyautofill/service/PasskeyAutofillCredentialProviderService.kt

@@ -0,0 +1,248 @@
+package co.algorand.passkeyautofill.service
+
+import android.app.PendingIntent
+import android.content.Intent
+import android.graphics.drawable.Icon
+import android.os.Build
+import android.os.Bundle
+import android.os.OutcomeReceiver
+import android.os.CancellationSignal
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.credentials.exceptions.ClearCredentialException
+import androidx.credentials.exceptions.CreateCredentialException
+import androidx.credentials.exceptions.CreateCredentialUnknownException
+import androidx.credentials.exceptions.GetCredentialException
+import androidx.credentials.exceptions.GetCredentialUnknownException
+import androidx.credentials.provider.BeginCreateCredentialRequest
+import androidx.credentials.provider.BeginCreateCredentialResponse
+import androidx.credentials.provider.BeginCreatePublicKeyCredentialRequest
+import androidx.credentials.provider.BeginGetCredentialRequest
+import androidx.credentials.provider.BeginGetCredentialResponse
+import androidx.credentials.provider.BeginGetPublicKeyCredentialOption
+import androidx.credentials.provider.CreateEntry
+import androidx.credentials.provider.CredentialProviderService
+import androidx.credentials.provider.ProviderClearCredentialStateRequest
+import androidx.credentials.provider.PublicKeyCredentialEntry
+import co.algorand.passkeyautofill.credentials.CredentialRepository
+import co.algorand.passkeyautofill.credentials.Credential
+import co.algorand.passkeyautofill.utils.PasskeyUtils
+import com.tencent.mmkv.MMKV
+import kotlinx.coroutines.*
+import org.json.JSONArray
+import org.json.JSONObject
+
+@RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+class PasskeyAutofillCredentialProviderService: CredentialProviderService() {
+    private val credentialRepository = CredentialRepository()
+    private val job = SupervisorJob()
+    private val scope = CoroutineScope(Dispatchers.IO + job)
+
+    companion object {
+        const val TAG = "PasskeyAutofillCredentialProviderService"
+        //TODO: App Lock Intents
+        const val GET_PASSKEY_INTENT = 1
+        const val CREATE_PASSKEY_INTENT = 2
+        const val DEFAULT_GET_PASSKEY_ACTION = "co.algorand.passkeyautofill.GET_PASSKEY"
+        const val DEFAULT_CREATE_PASSKEY_ACTION = "co.algorand.passkeyautofill.CREATE_PASSKEY"
+    }
+    /**
+     * Handle Create Credential Requests
+     */
+    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+    override fun onBeginCreateCredentialRequest(
+        request: BeginCreateCredentialRequest,
+        cancellationSignal: CancellationSignal,
+        callback: OutcomeReceiver<BeginCreateCredentialResponse, CreateCredentialException>
+    ) {
+        val response: BeginCreateCredentialResponse? = processCreateCredentialRequest(request)
+        if (response != null) {
+            callback.onResult(response)
+        } else {
+            callback.onError(CreateCredentialUnknownException())
+        }
+    }
+
+    /**
+     * Process incoming Create Credential Requests
+     */
+    private fun processCreateCredentialRequest(request: BeginCreateCredentialRequest): BeginCreateCredentialResponse? {
+        when (request) {
+            is BeginCreatePublicKeyCredentialRequest -> {
+                return handleCreatePasskeyQuery(request)
+            }
+        }
+        return null
+    }
+
+    /**
+     * Create a new PassKey Entry
+     *
+     * This returns an Entry list for the user to interact with.
+     * A PendingIntent must be configured to receive the data from the WebAuthn client
+     */
+    private fun handleCreatePasskeyQuery(
+        request: BeginCreatePublicKeyCredentialRequest
+    ): BeginCreateCredentialResponse {
+        val createEntries: MutableList<CreateEntry> = mutableListOf()
+        
+        // Ensure we have a master key available before offering to create a passkey
+        if (!credentialRepository.isMasterKeyAvailable(this)) {
+            return BeginCreateCredentialResponse(createEntries)
+        }
+
+        val userJson = JSONObject(request.requestJson).optJSONObject("user")
+        val name = userJson?.optString("name") ?: "New Passkey"
+
+        val action = credentialRepository.getCreatePasskeyAction(this) ?: DEFAULT_CREATE_PASSKEY_ACTION
+
+        val data = Bundle()
+        data.putString("requestJson", request.requestJson)
+
+        val createEntry = CreateEntry.Builder(
+            name,
+            createNewPendingIntent(action, CREATE_PASSKEY_INTENT, data)
+        ).setIcon(Icon.createWithResource(this, android.R.drawable.ic_menu_add))
+            .build()
+        
+        createEntries.add(createEntry)
+        return BeginCreateCredentialResponse(createEntries)
+    }
+    /**
+     * Handle Get Credential Requests
+     */
+    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+    override fun onBeginGetCredentialRequest(
+        request: BeginGetCredentialRequest,
+        cancellationSignal: CancellationSignal,
+        callback: OutcomeReceiver<BeginGetCredentialResponse, GetCredentialException>,
+    ) {
+        try {
+            val response = processGetCredentialRequest(request)
+            callback.onResult(response)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in onBeginGetCredentialRequest", e)
+            callback.onError(GetCredentialUnknownException())
+        }
+    }
+
+    /**
+     * Fake a list of available PublicKeyCredential Entries
+     */
+    private fun processGetCredentialRequest(request: BeginGetCredentialRequest): BeginGetCredentialResponse {
+        // Ensure we have a master key available. If not, we can't sign anything, so don't show entries.
+        if (!credentialRepository.isMasterKeyAvailable(this)) {
+            return BeginGetCredentialResponse(emptyList())
+        }
+
+        val credentials = runBlocking {
+            credentialRepository.getAllCredentials(this@PasskeyAutofillCredentialProviderService)
+        }
+
+        val action = credentialRepository.getGetPasskeyAction(this) ?: DEFAULT_GET_PASSKEY_ACTION
+        val allEntries = mutableListOf<PublicKeyCredentialEntry>()
+
+        for (option in request.beginGetCredentialOptions) {
+            if (option !is BeginGetPublicKeyCredentialOption) continue
+
+            val requestJsonStr = option.requestJson
+            var allowCredentials: JSONArray? = null
+            try {
+                val json = JSONObject(requestJsonStr)
+                val pk = if (json.has("publicKey")) json.getJSONObject("publicKey") else json
+                allowCredentials = pk.optJSONArray("allowCredentials")
+            } catch (e: Exception) {
+                Log.e(TAG, "Error parsing requestJson", e)
+            }
+
+            val allowedIds = if (allowCredentials != null && allowCredentials.length() > 0) {
+                val ids = mutableSetOf<String>()
+                for (i in 0 until allowCredentials.length()) {
+                    ids.add(allowCredentials.getJSONObject(i).getString("id"))
+                }
+                ids
+            } else {
+                null
+            }
+
+            for (credential in credentials) {
+                if (allowedIds != null) {
+                    val isAllowed = allowedIds.any { allowedId ->
+                        allowedId == credential.credentialId ||
+                        PasskeyUtils.normalizeBase64(allowedId) == PasskeyUtils.normalizeBase64(credential.credentialId)
+                    }
+                    if (!isAllowed) continue
+                }
+
+                try {
+                    val data = Bundle()
+                    data.putString("credentialId", credential.credentialId)
+                    data.putString("userHandle", credential.userHandle)
+                    data.putString("requestJson", option.requestJson)
+
+                    // Use a unique requestCode for each PendingIntent to avoid data being overwritten
+                    val uniqueRequestCode = (credential.credentialId + option.requestJson).hashCode()
+
+                    val entry = PublicKeyCredentialEntry.Builder(
+                        this,
+                        credential.userHandle,
+                        createNewPendingIntent(action, uniqueRequestCode, data),
+                        option
+                    )
+                        .setIcon(Icon.createWithResource(this, android.R.drawable.ic_lock_lock))
+                        .build()
+                    allEntries.add(entry)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error building PublicKeyCredentialEntry", e)
+                }
+            }
+        }
+        return BeginGetCredentialResponse(allEntries)
+    }
+
+    override fun onClearCredentialStateRequest(
+        request: ProviderClearCredentialStateRequest,
+        cancellationSignal: CancellationSignal,
+        callback: OutcomeReceiver<Void?, ClearCredentialException>
+    ) {
+        // TODO: Implement clear credential state if needed
+        callback.onResult(null)
+    }
+
+    private fun createNewPendingIntent(action: String, requestCode: Int, extra: Bundle?): PendingIntent{
+        MMKV.initialize(this)
+        val intent = Intent(action)
+
+        // Determine component based on action instead of requestCode
+        val getAction = credentialRepository.getGetPasskeyAction(this) ?: DEFAULT_GET_PASSKEY_ACTION
+        val createAction = credentialRepository.getCreatePasskeyAction(this) ?: DEFAULT_CREATE_PASSKEY_ACTION
+
+        val componentName = when(action) {
+            getAction -> android.content.ComponentName(packageName, "co.algorand.passkeyautofill.GetPasskeyActivity")
+            createAction -> android.content.ComponentName(packageName, "co.algorand.passkeyautofill.CreatePasskeyActivity")
+            else -> null
+        }
+
+        if (componentName != null) {
+            intent.component = componentName
+        } else {
+            intent.setPackage(packageName)
+        }
+
+        if (extra != null) {
+            intent.putExtra("CREDENTIAL_DATA", extra)
+        }
+        
+        // Add categories that might be required
+        intent.addCategory(android.content.Intent.CATEGORY_DEFAULT)
+        
+        return PendingIntent.getActivity(
+            applicationContext, requestCode,
+            intent, (PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)
+        )
+    }
+    override fun onDestroy() {
+        super.onDestroy()
+        job.cancel()
+    }
+}

package/android/src/main/java/co/algorand/passkeyautofill/utils/PasskeyUtils.kt

@@ -0,0 +1,7 @@
+package co.algorand.passkeyautofill.utils
+
+object PasskeyUtils {
+    fun normalizeBase64(s: String): String {
+        return s.replace("-", "+").replace("_", "/").replace("=", "")
+    }
+}

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="passkey_autofill_label">My Credential Provider</string>
+</resources>

package/android/src/main/res/values/styles.xml

@@ -0,0 +1,10 @@
+<resources>
+    <style name="Theme.PasskeyAutofill.Dialog" parent="Theme.AppCompat.Light.Dialog.MinWidth">
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowContentOverlay">@null</item>
+        <item name="android:windowNoTitle">true</item>
+        <item name="android:windowIsFloating">true</item>
+        <item name="android:backgroundDimEnabled">true</item>
+    </style>
+</resources>

package/android/src/main/res/xml/provider.xml

@@ -0,0 +1,5 @@
+<credential-provider xmlns:android="http://schemas.android.com/apk/res/android">
+    <capabilities>
+        <capability name="androidx.credentials.TYPE_PUBLIC_KEY_CREDENTIAL" />
+    </capabilities>
+</credential-provider>

package/app.plugin.js

@@ -0,0 +1,249 @@
+const {
+  withAndroidManifest,
+  withStringsXml,
+  withProjectBuildGradle,
+  withMainApplication,
+  withDangerousMod,
+  AndroidConfig,
+} = require("@expo/config-plugins");
+const path = require("path");
+const fs = require("fs");
+
+const withAndroidCookieModule = (config) => {
+  return withDangerousMod(config, [
+    "android",
+    async (config) => {
+      const projectRoot = config.modRequest.projectRoot;
+      const packageId = config.android?.package || "co.algorand.auth.example";
+      const packagePath = packageId.replace(/\./g, "/");
+      const targetDir = path.join(
+        projectRoot,
+        "android/app/src/main/java",
+        packagePath
+      );
+
+      // Ensure the directory exists
+      fs.mkdirSync(targetDir, { recursive: true });
+
+      const cookieModuleContent = `package ${packageId}
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import android.webkit.CookieManager
+
+class CookieModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName(): String {
+        return "CookieModule"
+    }
+
+    @ReactMethod
+    fun getCookie(url: String, promise: Promise) {
+        try {
+            val cookieManager = CookieManager.getInstance()
+            val cookie = cookieManager.getCookie(url)
+            promise.resolve(cookie)
+        } catch (e: Exception) {
+            promise.reject("E_COOKIE_MANAGER", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun setCookie(url: String, cookie: String, promise: Promise) {
+        try {
+            val cookieManager = CookieManager.getInstance()
+            cookieManager.setCookie(url, cookie)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("E_COOKIE_MANAGER", e.message)
+        }
+    }
+}
+`;
+
+      const cookiePackageContent = `package ${packageId}
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class CookiePackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(CookieModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
+`;
+
+      fs.writeFileSync(
+        path.join(targetDir, "CookieModule.kt"),
+        cookieModuleContent
+      );
+      fs.writeFileSync(
+        path.join(targetDir, "CookiePackage.kt"),
+        cookiePackageContent
+      );
+
+      return config;
+    },
+  ]);
+};
+
+const withUserAgent = (config) => {
+  return withMainApplication(config, (config) => {
+    let content = config.modResults.contents;
+
+    // Add imports
+    const imports = [
+      "import android.webkit.CookieManager",
+      "import com.facebook.react.modules.network.OkHttpClientProvider",
+      "import com.facebook.react.modules.network.ForwardingCookieHandler",
+      "import com.facebook.react.modules.network.ReactCookieJarContainer",
+      "import okhttp3.Interceptor",
+      "import okhttp3.JavaNetCookieJar",
+      "import java.net.CookieHandler",
+      "import android.os.Build",
+    ];
+
+    imports.forEach((imp) => {
+      if (!content.includes(imp)) {
+        content = content.replace(
+          /package .*\n/,
+          (match) => `${match}${imp}\n`
+        );
+      }
+    });
+
+    // Add OkHttpClient customization in onCreate
+    const okHttpClientCode = `
+    CookieManager.getInstance().setAcceptCookie(true)
+    CookieManager.setAcceptFileSchemeCookies(true)
+
+    OkHttpClientProvider.setOkHttpClientFactory {
+      val userAgent = "\${BuildConfig.APPLICATION_ID}/\${BuildConfig.VERSION_NAME} " +
+          "(Android \${Build.VERSION.RELEASE}; \${Build.MODEL}; \${Build.BRAND})"
+
+      val cookieHandler = ForwardingCookieHandler()
+      CookieHandler.setDefault(cookieHandler)
+
+      val cookieJarContainer = ReactCookieJarContainer()
+      cookieJarContainer.setCookieJar(JavaNetCookieJar(cookieHandler))
+
+      OkHttpClientProvider.createClientBuilder()
+        .cookieJar(cookieJarContainer)
+        .addInterceptor(Interceptor { chain ->
+          val request = chain.request().newBuilder().header("User-Agent", userAgent).build()
+          chain.proceed(request)
+        })
+        .build()
+    }
+`;
+
+    if (!content.includes("OkHttpClientProvider.setOkHttpClientFactory")) {
+      content = content.replace(
+        /super\.onCreate\(\)/,
+        `super.onCreate()${okHttpClientCode}`
+      );
+    }
+
+    // Register CookiePackage if it exists
+    if (!content.includes("add(CookiePackage())")) {
+      content = content.replace(
+        /PackageList\(this\)\.packages\.apply \{/,
+        `PackageList(this).packages.apply {\n              add(CookiePackage())`
+      );
+    }
+
+    config.modResults.contents = content;
+    return config;
+  });
+};
+
+const withPasskeyAutofill = (config, props = {}) => {
+  const site = props.site || "https://fido.shore-tech.net";
+  const label = props.label || "My Credential Provider";
+
+  config = withAndroidCookieModule(config);
+  config = withUserAgent(config);
+
+  // TODO: Move assetlinks to CLI
+  // 1. Add asset_statements meta-data to MainActivity
+  config = withAndroidManifest(config, async (config) => {
+    const mainActivity = config.modResults.manifest.application[0].activity.find(
+      (a) => a["$"]["android:name"] === ".MainActivity"
+    );
+    if (mainActivity) {
+      if (!mainActivity["meta-data"]) {
+        mainActivity["meta-data"] = [];
+      }
+      if (
+        !mainActivity["meta-data"].find(
+          (m) => m["$"]["android:name"] === "asset_statements"
+        )
+      ) {
+        mainActivity["meta-data"].push({
+          $: {
+            "android:name": "asset_statements",
+            "android:resource": "@string/asset_statements",
+          },
+        });
+      }
+    }
+    return config;
+  });
+
+  // 2. Add asset_statements string to strings.xml
+  config = withStringsXml(config, (config) => {
+    config.modResults = AndroidConfig.Strings.setStringItem(
+      [
+        {
+          $: { name: "asset_statements", translatable: "false" },
+          _: JSON.stringify([
+            {
+              relation: [
+                "delegate_permission/common.handle_all_urls",
+                "delegate_permission/common.get_login_creds",
+              ],
+              target: {
+                namespace: "web",
+                site: site,
+              },
+            },
+          ]),
+        },
+        {
+          $: { name: "passkey_autofill_label", translatable: "true" },
+          _: label,
+        },
+      ],
+      config.modResults
+    );
+    return config;
+  });
+
+  // 3. Add flatDir repository for local AAR
+  config = withProjectBuildGradle(config, (config) => {
+    if (config.modResults.contents.includes("dP256Android-release")) {
+      return config;
+    }
+    const libsDir = "../../android/libs";
+    config.modResults.contents = config.modResults.contents.replace(
+      /allprojects\s*{[\s\n]*repositories\s*{/,
+      `allprojects {
+  repositories {
+    flatDir {
+      dirs "$rootDir/${libsDir}"
+    }`
+    );
+    return config;
+  });
+
+  return config;
+};
+
+module.exports = withPasskeyAutofill;

package/build/ReactNativePasskeyAutofill.types.d.ts

@@ -0,0 +1,9 @@
+export type ReactNativePasskeyAutofillModuleEvents = {
+    onPasskeyAdded: (event: {
+        success: boolean;
+    }) => void;
+    onPasskeyAuthenticated: (event: {
+        success: boolean;
+    }) => void;
+};
+//# sourceMappingURL=ReactNativePasskeyAutofill.types.d.ts.map

package/build/ReactNativePasskeyAutofill.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactNativePasskeyAutofill.types.d.ts","sourceRoot":"","sources":["../src/ReactNativePasskeyAutofill.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sCAAsC,GAAG;IACnD,cAAc,EAAE,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IACtD,sBAAsB,EAAE,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;CAC/D,CAAC"}

package/build/ReactNativePasskeyAutofill.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ReactNativePasskeyAutofill.types.js.map

package/build/ReactNativePasskeyAutofill.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactNativePasskeyAutofill.types.js","sourceRoot":"","sources":["../src/ReactNativePasskeyAutofill.types.ts"],"names":[],"mappings":"","sourcesContent":["export type ReactNativePasskeyAutofillModuleEvents = {\n  onPasskeyAdded: (event: { success: boolean }) => void;\n  onPasskeyAuthenticated: (event: { success: boolean }) => void;\n};\n"]}

package/build/ReactNativePasskeyAutofillModule.d.ts

@@ -0,0 +1,12 @@
+import { NativeModule } from 'expo';
+import { ReactNativePasskeyAutofillModuleEvents } from './ReactNativePasskeyAutofill.types';
+declare class ReactNativePasskeyAutofillModule extends NativeModule<ReactNativePasskeyAutofillModuleEvents> {
+    setMasterKey(secret: string): Promise<void>;
+    setHdRootKeyId(id: string): Promise<void>;
+    getHdRootKeyId(): Promise<string | null>;
+    configureIntentActions(getPasskeyAction: string, createPasskeyAction: string): Promise<void>;
+    clearCredentials(): Promise<void>;
+}
+declare const _default: ReactNativePasskeyAutofillModule;
+export default _default;
+//# sourceMappingURL=ReactNativePasskeyAutofillModule.d.ts.map

package/build/ReactNativePasskeyAutofillModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactNativePasskeyAutofillModule.d.ts","sourceRoot":"","sources":["../src/ReactNativePasskeyAutofillModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,EAAE,sCAAsC,EAAE,MAAM,oCAAoC,CAAC;AAE5F,OAAO,OAAO,gCAAiC,SAAQ,YAAY,CAAC,sCAAsC,CAAC;IACzG,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAC3C,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IACzC,cAAc,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IACxC,sBAAsB,CAAC,gBAAgB,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAC5F,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;CAClC;;AAGD,wBAAmG"}

package/build/ReactNativePasskeyAutofillModule.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo';
+// This call loads the native module object from the JSI.
+export default requireNativeModule('ReactNativePasskeyAutofill');
+//# sourceMappingURL=ReactNativePasskeyAutofillModule.js.map

package/build/ReactNativePasskeyAutofillModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactNativePasskeyAutofillModule.js","sourceRoot":"","sources":["../src/ReactNativePasskeyAutofillModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAYzD,yDAAyD;AACzD,eAAe,mBAAmB,CAAmC,4BAA4B,CAAC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from 'expo';\n\nimport { ReactNativePasskeyAutofillModuleEvents } from './ReactNativePasskeyAutofill.types';\n\ndeclare class ReactNativePasskeyAutofillModule extends NativeModule<ReactNativePasskeyAutofillModuleEvents> {\n  setMasterKey(secret: string): Promise<void>;\n  setHdRootKeyId(id: string): Promise<void>;\n  getHdRootKeyId(): Promise<string | null>;\n  configureIntentActions(getPasskeyAction: string, createPasskeyAction: string): Promise<void>;\n  clearCredentials(): Promise<void>;\n}\n\n// This call loads the native module object from the JSI.\nexport default requireNativeModule<ReactNativePasskeyAutofillModule>('ReactNativePasskeyAutofill');\n"]}

package/build/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './ReactNativePasskeyAutofillModule';
+export * from './ReactNativePasskeyAutofill.types';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAC7D,cAAe,oCAAoC,CAAC"}

package/build/index.js

@@ -0,0 +1,5 @@
+// Reexport the native module. On web, it will be resolved to ReactNativePasskeyAutofillModule.web.ts
+// and on native platforms to ReactNativePasskeyAutofillModule.ts
+export { default } from './ReactNativePasskeyAutofillModule';
+export * from './ReactNativePasskeyAutofill.types';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,qGAAqG;AACrG,iEAAiE;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAC7D,cAAe,oCAAoC,CAAC","sourcesContent":["// Reexport the native module. On web, it will be resolved to ReactNativePasskeyAutofillModule.web.ts\n// and on native platforms to ReactNativePasskeyAutofillModule.ts\nexport { default } from './ReactNativePasskeyAutofillModule';\nexport * from  './ReactNativePasskeyAutofill.types';\n"]}

package/expo-module.config.json

@@ -0,0 +1,10 @@
+{
+  "platforms": ["apple", "android", "web"],
+  "apple": {
+    "modules": ["ReactNativePasskeyAutofillModule"]
+  },
+  "android": {
+    "modules": ["co.algorand.passkeyautofill.ReactNativePasskeyAutofillModule"]
+  },
+  "plugin": "./app.plugin.js"
+}

package/ios/ReactNativePasskeyAutofill.podspec

@@ -0,0 +1,29 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ReactNativePasskeyAutofill'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1'
+  }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/algorandfoundation/react-native-passkey-autofill' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end