capacitor-didit-plugin 0.1.0

package/CapacitorDiditPlugin.podspec

@@ -0,0 +1,20 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorDiditPlugin'
+  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 = '15.0'
+  s.dependency 'Capacitor'
+  # DiditSDK is not published to the CocoaPods trunk — the consuming app's
+  # Podfile must declare it with its podspec URL (see README installation).
+  s.dependency 'DiditSDK/All'
+  s.swift_version = '5.1'
+end

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aurora Systems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Package.swift

@@ -0,0 +1,30 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapacitorDiditPlugin",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "CapacitorDiditPlugin",
+            targets: ["DiditVerificationPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0"),
+        .package(url: "https://github.com/didit-protocol/sdk-ios.git", from: "4.1.0")
+    ],
+    targets: [
+        .target(
+            name: "DiditVerificationPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm"),
+                .product(name: "DiditSDK", package: "sdk-ios")
+            ],
+            path: "ios/Sources/DiditVerificationPlugin"),
+        .testTarget(
+            name: "DiditVerificationPluginTests",
+            dependencies: ["DiditVerificationPlugin"],
+            path: "ios/Tests/DiditVerificationPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,162 @@
+# capacitor-didit-plugin
+
+Capacitor plugin that wraps the native [Didit](https://didit.me) identity-verification (KYC) SDKs for iOS and Android, so verification (document capture, liveness, NFC passport reading) runs fully in-app — no browser window.
+
+- iOS: [didit-protocol/sdk-ios](https://github.com/didit-protocol/sdk-ios) (`DiditSDK` 4.x)
+- Android: [didit-protocol/sdk-android](https://github.com/didit-protocol/sdk-android) (`me.didit:didit-sdk` 4.x)
+
+Requires **Capacitor 8**, iOS 15+, Android minSdk 24 (Capacitor 8 defaults).
+
+## Install
+
+```bash
+npm install capacitor-didit-plugin
+npx cap sync
+```
+
+The plugin is auto-registered by Capacitor on both platforms — do **not** add `registerPlugin` calls in `MainActivity`, custom `CAPBridgeViewController` subclasses, or `packageClassList` patch scripts.
+
+### iOS setup
+
+**Swift Package Manager apps (the default for new Capacitor 8 projects): no dependency steps.** The plugin ships a `Package.swift` that pulls `DiditSDK` automatically — `npx cap sync ios` is enough. Skip to step 2 (Info.plist).
+
+**CocoaPods apps (projects migrated from Capacitor ≤ 7):**
+
+**1. Add the Didit SDK pod to your app's Podfile.** The Didit SDK is not published to the CocoaPods trunk; it is resolved from a podspec URL. In `ios/App/Podfile`, add this line inside the `target 'App' do` block (below `capacitor_pods` — Capacitor rewrites the `capacitor_pods` section on every sync, but lines you add directly in the target block persist):
+
+```ruby
+target 'App' do
+  capacitor_pods
+  # Add your Pods here
+  pod 'DiditSDK/All', :podspec => 'https://raw.githubusercontent.com/didit-protocol/sdk-ios/main/DiditSDK.podspec'
+end
+```
+
+Use the `All` subspec — the plugin's podspec depends on `DiditSDK/All`.
+
+**2. Add usage descriptions to `ios/App/App/Info.plist`:**
+
+```xml
+<key>NSCameraUsageDescription</key>
+<string>Camera access is required to scan your identity document and verify liveness.</string>
+<key>NSMicrophoneUsageDescription</key>
+<string>Microphone access is required for liveness video verification.</string>
+<key>NSPhotoLibraryUsageDescription</key>
+<string>Photo library access lets you upload document images.</string>
+```
+
+If you use NFC passport reading, also follow [Didit's NFC setup](https://github.com/didit-protocol/sdk-ios#nfc) (NFC capability, `NFCReaderUsageDescription`, ISO7816 select identifiers).
+
+**3. Run `npx cap sync ios`** (which runs `pod install`).
+
+#### iOS troubleshooting
+
+- **`pod install` fails with "unknown project version" / cannot open `project.pbxproj`** — your project was saved in a new Xcode format (objectVersion 70, Xcode 16.3+/26) that older CocoaPods tooling can't parse. Update the `xcodeproj` gem to ≥ 1.28: `gem install xcodeproj` (or `sudo gem update xcodeproj`), then re-run `pod install`.
+- **"Unable to find a specification for `DiditSDK/All`"** — the `pod 'DiditSDK/All', :podspec => …` line is missing from your Podfile (step 1).
+
+### Android setup
+
+The plugin's `build.gradle` declares the Didit Maven repository (`raw.githubusercontent.com/didit-protocol/sdk-android`) and JitPack (needed for some of the SDK's transitive dependencies) and injects them into the consuming build, applies Kotlin itself, and pins the Kotlin/Java toolchain to JDK 21 — your app needs **no** repository or Kotlin configuration in the default Capacitor project layout. A plain Capacitor 8 app builds with no extra steps.
+
+**(Only if your `settings.gradle` centralizes repositories.)** If you use `dependencyResolutionManagement` with `RepositoriesMode.FAIL_ON_PROJECT_REPOS` or `PREFER_SETTINGS`, project-level repositories (including the ones this plugin injects) are ignored — add them centrally instead:
+
+```groovy
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+        maven { url "https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository" }
+        maven { url "https://jitpack.io" }
+    }
+}
+```
+
+The default Capacitor app template does not use `dependencyResolutionManagement`, so most apps can skip this.
+
+#### Android troubleshooting
+
+- **`Unsupported class file major version 69` (or similar) when Gradle starts** — your default JDK is newer than Capacitor 8's Gradle supports. Build with JDK 21, e.g. `export JAVA_HOME="/Applications/Android Studio.app/Contents/jbr/Contents/Home"` (Android Studio's bundled JDK) before running Gradle, or install Temurin 21.
+- **`Could not find me.didit:didit-sdk`** — your build ignores project-level repositories; see the `dependencyResolutionManagement` note above.
+- **`2 files found with path 'META-INF/versions/9/OSGI-INF/MANIFEST.MF'`** — happens when another dependency in your app ships the same multi-release-jar manifest as one of the Didit SDK's transitive dependencies (seen e.g. alongside OneSignal). Add the exclusion to `android/app/build.gradle` inside the `android { }` block:
+
+  ```groovy
+  packagingOptions {
+      resources {
+          excludes += 'META-INF/versions/9/OSGI-INF/MANIFEST.MF'
+      }
+  }
+  ```
+- **Out-of-memory / metaspace errors during build** — the Didit SDK pulls in Jetpack Compose; raise the Gradle heap in `android/gradle.properties`: `org.gradle.jvmargs=-Xmx4096m -XX:MaxMetaspaceSize=512m`.
+- **Kotlin `jvmTarget` mismatch errors from *other* plugins** — some third-party Kotlin plugins don't pin a jvmTarget and default to your running JDK. Pin every Kotlin module in your app's root `android/build.gradle`:
+
+  ```groovy
+  subprojects {
+      plugins.withId('org.jetbrains.kotlin.android') {
+          project.extensions.getByName('kotlin').jvmToolchain(21)
+      }
+  }
+  ```
+
+  (This plugin already pins its own toolchain; the snippet is only for others that don't.)
+- **R8 full mode issues in release builds** — the SDK ships consumer ProGuard rules; if you still hit R8 full-mode problems, set `android.enableR8.fullMode=false` in `gradle.properties`.
+
+## Usage
+
+Create a verification session **from your backend** (Didit `POST /v2/session/`), pass the session token to the app, then:
+
+```typescript
+import { DiditVerification } from 'capacitor-didit-plugin';
+
+async function verifyIdentity(sessionToken: string) {
+  try {
+    const result = await DiditVerification.startVerification({ sessionToken });
+    // result.status: 'Approved' | 'Pending' | 'Declined'
+    // result.sessionId: reconcile with your backend / webhooks
+    return result;
+  } catch (err: any) {
+    if (err.code === 'CANCELLED') {
+      // user closed the flow
+    }
+    throw err;
+  }
+}
+```
+
+`Pending` means the session completed but the decision isn't final (processing or manual review) — treat the Didit webhook / API status on your backend as the source of truth.
+
+## API
+
+### `startVerification(options: { sessionToken: string }): Promise<DiditVerificationResult>`
+
+Launches the native Didit verification flow and resolves when the user finishes.
+
+```typescript
+interface DiditVerificationResult {
+  status: 'Approved' | 'Pending' | 'Declined';
+  sessionId: string;
+}
+```
+
+On web the call rejects as unavailable — gate it with `Capacitor.isNativePlatform()` and fall back to Didit's hosted web verification URL.
+
+### Error codes
+
+| `err.code`      | Meaning                                                     |
+| --------------- | ----------------------------------------------------------- |
+| `MISSING_TOKEN` | `sessionToken` was absent or empty.                         |
+| `BUSY`          | A verification flow is already running.                     |
+| `UNAVAILABLE`   | No activity / view controller to present from, or platform is web. |
+| `CANCELLED`     | The user exited the flow before completing it.              |
+| `FAILED`        | The SDK reported an error — see the error message.          |
+
+## Migrating from an in-app (local) plugin
+
+If you previously wired the Didit SDK into your app project directly, remove the old wiring after installing this package:
+
+- **iOS:** delete the local `DiditVerificationPlugin.swift` / bridge files, the custom `ViewController` subclass with `registerPluginInstance`, any `capacitor.config.json` `packageClassList` patch script, and restore `Main.storyboard`'s controller class if you changed it. Keep the `pod 'DiditSDK/All'` Podfile line.
+- **Android:** delete the local `DiditVerificationPlugin.kt`, remove `registerPlugin(DiditVerificationPlugin.class)` from `MainActivity`, and remove `me.didit:didit-sdk` plus the Didit Maven repo from your **app** module (the plugin brings both). Your app also no longer needs `apply plugin: 'kotlin-android'` or the Kotlin classpath if nothing else uses Kotlin.
+- **JS:** replace imports of the local `src/plugins/DiditVerification` module with `import { DiditVerification } from 'capacitor-didit-plugin'`. The API is identical; cancellations now reject with `code: 'CANCELLED'`.
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,82 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+    diditSdkVersion = project.hasProperty('diditSdkVersion') ? rootProject.ext.diditSdkVersion : '4.1.0'
+}
+
+buildscript {
+    ext.kotlin_version = project.hasProperty("kotlin_version") ? rootProject.ext.kotlin_version : '2.2.20'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace = "zw.co.aurorasystems.plugins.didit"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+kotlin {
+    jvmToolchain(21)
+}
+
+repositories {
+    google()
+    mavenCentral()
+    // The Didit SDK is published to a GitHub-hosted Maven repository, and
+    // some of its transitive dependencies resolve from JitPack.
+    maven { url "https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository" }
+    maven { url "https://jitpack.io" }
+}
+
+// The consuming app resolves this module's didit-sdk dependency on its own
+// runtime classpath, using the app's repositories — not this module's. Inject
+// the Didit repositories into every project so consumers need no manual repo
+// setup. (Apps that centralize repositories in settings.gradle with
+// FAIL_ON_PROJECT_REPOS must add them there instead — see README.)
+rootProject.allprojects {
+    repositories {
+        maven { url "https://raw.githubusercontent.com/didit-protocol/sdk-android/main/repository" }
+        maven { url "https://jitpack.io" }
+    }
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "me.didit:didit-sdk:$diditSdkVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/proguard-rules.pro

@@ -0,0 +1,2 @@
+# The Didit SDK ships its own consumer ProGuard rules; nothing extra is
+# required for this plugin.

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/zw/co/aurorasystems/plugins/didit/DiditVerificationPlugin.kt

@@ -0,0 +1,86 @@
+package zw.co.aurorasystems.plugins.didit
+
+import android.app.Application
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import me.didit.sdk.DiditSdk
+import me.didit.sdk.VerificationResult
+
+@CapacitorPlugin(name = "DiditVerification")
+class DiditVerificationPlugin : Plugin() {
+
+    @Volatile
+    private var activeCallbackId: String? = null
+
+    override fun load() {
+        DiditSdk.initialize(context.applicationContext as Application)
+    }
+
+    override fun handleOnDestroy() {
+        activeCallbackId = null
+    }
+
+    @PluginMethod
+    fun startVerification(call: PluginCall) {
+        val sessionToken = call.getString("sessionToken")
+        if (sessionToken.isNullOrEmpty()) {
+            call.reject("sessionToken is required", "MISSING_TOKEN")
+            return
+        }
+
+        val currentActivity = activity
+        if (currentActivity == null) {
+            call.reject("Activity is not available", "UNAVAILABLE")
+            return
+        }
+
+        if (activeCallbackId != null) {
+            call.reject("A verification is already in progress", "BUSY")
+            return
+        }
+
+        // Save the call so it survives configuration changes while the
+        // SDK's activity is in the foreground.
+        bridge.saveCall(call)
+        activeCallbackId = call.callbackId
+
+        currentActivity.runOnUiThread {
+            DiditSdk.startVerification(token = sessionToken) { result ->
+                // Clear the busy flag before the null-guard: a WebView reload
+                // resets the bridge and drops saved calls, and the guard must
+                // not leave the plugin permanently locked in that case.
+                activeCallbackId = null
+
+                // getSavedCall returning null means the call was already
+                // settled or dropped by a bridge reset — guards against the
+                // SDK firing the callback twice.
+                val savedCall = bridge.getSavedCall(call.callbackId) ?: return@startVerification
+                bridge.releaseCall(savedCall)
+
+                when (result) {
+                    is VerificationResult.Completed -> {
+                        val ret = JSObject()
+                        ret.put("status", mapStatus(result.session.status.name))
+                        ret.put("sessionId", result.session.sessionId)
+                        savedCall.resolve(ret)
+                    }
+                    is VerificationResult.Cancelled -> {
+                        savedCall.reject("Verification cancelled", "CANCELLED")
+                    }
+                    is VerificationResult.Failed -> {
+                        savedCall.reject(result.error.message ?: "Verification failed", "FAILED")
+                    }
+                }
+            }
+        }
+    }
+
+    private fun mapStatus(rawStatus: String): String = when (rawStatus.uppercase()) {
+        "APPROVED" -> "Approved"
+        "DECLINED" -> "Declined"
+        else -> "Pending"
+    }
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The final status of a completed Didit verification session.
+ */
+export type DiditVerificationStatus = 'Approved' | 'Pending' | 'Declined';
+export interface DiditVerificationResult {
+    /**
+     * The session status reported by the Didit SDK when the flow completed.
+     *
+     * `Pending` means the session finished but is still being processed or
+     * needs manual review — poll the Didit API from your backend for the
+     * final decision.
+     */
+    status: DiditVerificationStatus;
+    /**
+     * The Didit verification session id, for reconciliation with your backend.
+     */
+    sessionId: string;
+}
+export interface StartVerificationOptions {
+    /**
+     * The session token created for this user via the Didit API
+     * (`POST /v2/session/` from your backend).
+     */
+    sessionToken: string;
+}
+export interface DiditVerificationPlugin {
+    /**
+     * Launch the native Didit verification flow (document capture, liveness,
+     * NFC where available) and resolve when the user finishes.
+     *
+     * Rejects with `code`:
+     * - `MISSING_TOKEN` — `sessionToken` was absent or empty.
+     * - `BUSY` — a verification flow is already running.
+     * - `UNAVAILABLE` — no activity / view controller to present from,
+     *   or the platform is web.
+     * - `CANCELLED` — the user exited the flow before completing it.
+     * - `FAILED` — the SDK reported an error (message has details).
+     */
+    startVerification(options: StartVerificationOptions): Promise<DiditVerificationResult>;
+}

package/dist/esm/definitions.js

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

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":""}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { DiditVerificationPlugin } from './definitions';
+declare const DiditVerification: DiditVerificationPlugin;
+export * from './definitions';
+export { DiditVerification };

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { registerPlugin } from '@capacitor/core';
+const DiditVerification = registerPlugin('DiditVerification', {
+    web: () => import('./web').then((m) => new m.DiditVerificationWeb()),
+});
+export * from './definitions';
+export { DiditVerification };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,MAAM,iBAAiB,GAAG,cAAc,CAA0B,mBAAmB,EAAE;IACrF,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,oBAAoB,EAAE,CAAC;CACrE,CAAC,CAAC;AAEH,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/esm/web.d.ts

@@ -0,0 +1,5 @@
+import { WebPlugin } from '@capacitor/core';
+import type { DiditVerificationPlugin, DiditVerificationResult } from './definitions';
+export declare class DiditVerificationWeb extends WebPlugin implements DiditVerificationPlugin {
+    startVerification(): Promise<DiditVerificationResult>;
+}

package/dist/esm/web.js

@@ -0,0 +1,7 @@
+import { WebPlugin } from '@capacitor/core';
+export class DiditVerificationWeb extends WebPlugin {
+    async startVerification() {
+        throw this.unavailable('The Didit native SDK is not available on web. Use the Didit web verification URL instead.');
+    }
+}
+//# sourceMappingURL=web.js.map

package/dist/esm/web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.js","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,MAAM,OAAO,oBAAqB,SAAQ,SAAS;IACjD,KAAK,CAAC,iBAAiB;QACrB,MAAM,IAAI,CAAC,WAAW,CACpB,2FAA2F,CAC5F,CAAC;IACJ,CAAC;CACF"}

package/dist/plugin.cjs.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var core = require('@capacitor/core');
+
+const DiditVerification = core.registerPlugin('DiditVerification', {
+    web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.DiditVerificationWeb()),
+});
+
+class DiditVerificationWeb extends core.WebPlugin {
+    async startVerification() {
+        throw this.unavailable('The Didit native SDK is not available on web. Use the Didit web verification URL instead.');
+    }
+}
+
+var web = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DiditVerificationWeb: DiditVerificationWeb
+});
+
+exports.DiditVerification = DiditVerification;
+//# sourceMappingURL=plugin.cjs.js.map

package/dist/plugin.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.cjs.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst DiditVerification = registerPlugin('DiditVerification', {\n    web: () => import('./web').then((m) => new m.DiditVerificationWeb()),\n});\nexport * from './definitions';\nexport { DiditVerification };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class DiditVerificationWeb extends WebPlugin {\n    async startVerification() {\n        throw this.unavailable('The Didit native SDK is not available on web. Use the Didit web verification URL instead.');\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;;AACK,MAAC,iBAAiB,GAAGA,mBAAc,CAAC,mBAAmB,EAAE;AAC9D,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,oBAAoB,EAAE,CAAC;AACxE,CAAC;;ACFM,MAAM,oBAAoB,SAASC,cAAS,CAAC;AACpD,IAAI,MAAM,iBAAiB,GAAG;AAC9B,QAAQ,MAAM,IAAI,CAAC,WAAW,CAAC,2FAA2F,CAAC;AAC3H,IAAI;AACJ;;;;;;;;;"}

package/dist/plugin.js

@@ -0,0 +1,24 @@
+var capacitorDiditVerification = (function (exports, core) {
+    'use strict';
+
+    const DiditVerification = core.registerPlugin('DiditVerification', {
+        web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.DiditVerificationWeb()),
+    });
+
+    class DiditVerificationWeb extends core.WebPlugin {
+        async startVerification() {
+            throw this.unavailable('The Didit native SDK is not available on web. Use the Didit web verification URL instead.');
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        DiditVerificationWeb: DiditVerificationWeb
+    });
+
+    exports.DiditVerification = DiditVerification;
+
+    return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst DiditVerification = registerPlugin('DiditVerification', {\n    web: () => import('./web').then((m) => new m.DiditVerificationWeb()),\n});\nexport * from './definitions';\nexport { DiditVerification };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class DiditVerificationWeb extends WebPlugin {\n    async startVerification() {\n        throw this.unavailable('The Didit native SDK is not available on web. Use the Didit web verification URL instead.');\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;AACK,UAAC,iBAAiB,GAAGA,mBAAc,CAAC,mBAAmB,EAAE;IAC9D,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,oBAAoB,EAAE,CAAC;IACxE,CAAC;;ICFM,MAAM,oBAAoB,SAASC,cAAS,CAAC;IACpD,IAAI,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,MAAM,IAAI,CAAC,WAAW,CAAC,2FAA2F,CAAC;IAC3H,IAAI;IACJ;;;;;;;;;;;;;;;"}

package/ios/Sources/DiditVerificationPlugin/DiditVerificationBridge.swift

@@ -0,0 +1,112 @@
+import SwiftUI
+import UIKit
+import DiditSDK
+
+// MARK: - Result types passed back to the Capacitor plugin
+
+struct DiditNativeResult {
+    let status: String   // "Approved" | "Pending" | "Declined"
+    let sessionId: String
+}
+
+enum DiditNativeError: LocalizedError {
+    case cancelled
+    case sdkError(String)
+
+    var code: String {
+        switch self {
+        case .cancelled: return "CANCELLED"
+        case .sdkError: return "FAILED"
+        }
+    }
+
+    var errorDescription: String? {
+        switch self {
+        case .cancelled: return "Verification cancelled"
+        case .sdkError(let msg): return msg
+        }
+    }
+}
+
+// MARK: - Transparent SwiftUI view that registers the DiditSDK callback
+
+private struct DiditBridgeView: View {
+    let onResult: (Result<DiditNativeResult, Error>) -> Void
+
+    var body: some View {
+        Color.clear
+            .ignoresSafeArea()
+            .diditVerification { sdkResult in
+                switch sdkResult {
+                case .completed(let session):
+                    let status: String
+                    switch session.status {
+                    case .approved: status = "Approved"
+                    case .declined: status = "Declined"
+                    default: status = "Pending"
+                    }
+                    onResult(.success(DiditNativeResult(
+                        status: status,
+                        sessionId: session.sessionId
+                    )))
+
+                case .cancelled:
+                    onResult(.failure(DiditNativeError.cancelled))
+
+                case .failed(let error, _):
+                    onResult(.failure(DiditNativeError.sdkError(error.localizedDescription)))
+                }
+            }
+    }
+}
+
+// MARK: - Bridge that presents the SwiftUI host and launches the SDK
+
+final class DiditVerificationBridge {
+
+    static func present(
+        from presentingVC: UIViewController,
+        sessionToken: String,
+        completion: @escaping (Result<DiditNativeResult, Error>) -> Void
+    ) {
+        // Present from the top-most controller — presenting from a controller
+        // that already has a modal up fails silently in UIKit.
+        var topVC = presentingVC
+        while let presented = topVC.presentedViewController {
+            topVC = presented
+        }
+
+        var hosting: UIHostingController<DiditBridgeView>?
+
+        // Guard against the SDK firing the callback more than once (e.g. a
+        // completed event followed by a cleanup event). The second invocation
+        // would call resolve/reject on an already-settled CAPPluginCall, which
+        // crashes the bridge on iOS 17+.
+        var didComplete = false
+        let onceCompletion: (Result<DiditNativeResult, Error>) -> Void = { result in
+            guard !didComplete else { return }
+            didComplete = true
+            DispatchQueue.main.async {
+                hosting?.dismiss(animated: false)
+                hosting = nil
+                completion(result)
+            }
+        }
+
+        let bridgeView = DiditBridgeView(onResult: onceCompletion)
+
+        let hc = UIHostingController(rootView: bridgeView)
+        hc.view.backgroundColor = .clear
+        // overFullScreen keeps the underlying UI visible while DiditSDK
+        // presents its own screens on top.
+        hc.modalPresentationStyle = .overFullScreen
+        hosting = hc
+
+        topVC.present(hc, animated: false) {
+            // The SwiftUI environment with .diditVerification is now active;
+            // the SDK finds the top view controller and the registered
+            // callback through the environment.
+            DiditSdk.shared.startVerification(token: sessionToken)
+        }
+    }
+}

package/ios/Sources/DiditVerificationPlugin/DiditVerificationPlugin.swift

@@ -0,0 +1,62 @@
+import Foundation
+import Capacitor
+
+@objc(DiditVerificationPlugin)
+public class DiditVerificationPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "DiditVerificationPlugin"
+    public let jsName = "DiditVerification"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "startVerification", returnType: CAPPluginReturnPromise)
+    ]
+
+    private var isVerificationActive = false
+
+    @objc func startVerification(_ call: CAPPluginCall) {
+        guard let sessionToken = call.getString("sessionToken"), !sessionToken.isEmpty else {
+            call.reject("sessionToken is required", "MISSING_TOKEN")
+            return
+        }
+
+        // Keep the call alive across the async gap so the bridge doesn't
+        // release it before the SDK callback fires.
+        call.keepAlive = true
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            let finish: (CAPPluginCall) -> Void = { [weak self] call in
+                self?.bridge?.releaseCall(call)
+            }
+
+            guard !self.isVerificationActive else {
+                call.reject("A verification is already in progress", "BUSY")
+                finish(call)
+                return
+            }
+
+            guard let rootVC = self.bridge?.viewController else {
+                call.reject("No view controller available", "UNAVAILABLE")
+                finish(call)
+                return
+            }
+
+            self.isVerificationActive = true
+
+            DiditVerificationBridge.present(from: rootVC, sessionToken: sessionToken) { [weak self] result in
+                self?.isVerificationActive = false
+
+                switch result {
+                case .success(let verification):
+                    call.resolve([
+                        "status": verification.status,
+                        "sessionId": verification.sessionId
+                    ])
+                case .failure(let error):
+                    let code = (error as? DiditNativeError)?.code ?? "FAILED"
+                    call.reject(error.localizedDescription, code)
+                }
+                finish(call)
+            }
+        }
+    }
+}

package/ios/Tests/DiditVerificationPluginTests/DiditVerificationPluginTests.swift

@@ -0,0 +1,10 @@
+import XCTest
+@testable import DiditVerificationPlugin
+
+class DiditVerificationPluginTests: XCTestCase {
+    func testPluginIdentity() {
+        let plugin = DiditVerificationPlugin()
+        XCTAssertEqual(plugin.jsName, "DiditVerification")
+        XCTAssertEqual(plugin.pluginMethods.count, 1)
+    }
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "capacitor-didit-plugin",
+  "version": "0.1.0",
+  "description": "Capacitor plugin wrapping the native Didit identity verification (KYC) SDKs for iOS and Android",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "android/proguard-rules.pro",
+    "dist/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CapacitorDiditPlugin.podspec"
+  ],
+  "author": "Aurora Systems <zkomichi@aurorasystems.co.zw>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aurora-systems/capacitor-didit-plugin.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aurora-systems/capacitor-didit-plugin/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native",
+    "didit",
+    "kyc",
+    "identity-verification",
+    "liveness"
+  ],
+  "scripts": {
+    "verify": "npm run verify:web",
+    "verify:web": "npm run build",
+    "build": "npm run clean && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/core": "^8.0.0",
+    "@capacitor/ios": "^8.0.0",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.30.1",
+    "typescript": "^5.9.0"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}