@rdlabo/capacitor-native-ui 0.0.0-stage → 1.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021
+
+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,23 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "RdlaboCapacitorNativeUi",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(name: "RdlaboCapacitorNativeUi", targets: ["NativeUIPlugin"])
+    ],
+    dependencies: [.package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")],
+    targets: [.target(
+        name: "NativeUIPlugin",
+        dependencies: [
+            .product(name: "Capacitor", package: "capacitor-swift-pm"),
+            .product(name: "Cordova", package: "capacitor-swift-pm")
+        ],
+        path: "ios/Sources/NativeUIPlugin"
+    ), .testTarget(
+        name: "NativeUIPluginTests",
+        dependencies: ["NativeUIPlugin"],
+        path: "ios/Tests/NativeUIPluginTests"
+    )]
+)

package/README.md

@@ -1,3 +1,54 @@
-# Temporary Holding Version
+# Capacitor Native UI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> **Unreleased package:** the first npm release of `@rdlabo/capacitor-native-ui` is pending. The registry install commands in these guides apply after that release. To try the current code now, install a candidate archive as described below.
+
+Render supported Web controls with UIKit and SwiftUI on iOS while keeping your application state, routing, and handlers in the WebView. Use existing Ionic markup or explicit HTML buttons; custom SwiftUI or Android Compose content can be added through experimental app-local extensions.
+
+Native UI is opt-in and currently a preview. Standard controls on Android, browsers, older iOS, and unsupported controls retain Web presentation. Android supports experimental app-local Compose extensions. Keep your application's styles and layout; the iOS theme is optional.
+
+## Choose what to build
+
+| Goal | Start here |
+| --- | --- |
+| Render existing Ionic controls natively | [Ionic setup](docs/setup.md) |
+| Use native buttons without Ionic | [HTML setup](docs/framework-independent.md) |
+| Project only tabs and toolbar actions into a side rail | [Vertical Bars step by step](https://github.com/rdlabo-dev/ionic-theme-ios27/blob/main/packages/theme-ios27/docs/iphone-duo-with-original-theme.md) |
+| Add native controls to an existing iOS 27 theme app | [Add Native UI to your theme](https://github.com/rdlabo-dev/ionic-theme-ios27/blob/main/packages/theme-ios27/docs/add-native-ui.md) |
+| Render custom SwiftUI or Android Compose content | [App-local extensions (experimental)](docs/native-ui-extensions.md) |
+
+## Try the unreleased packages
+
+1. Open a successful [Package Candidate run](https://github.com/rdlabo-dev/ionic-theme-ios27/actions/workflows/package-candidate.yml) for the commit you want to try. Use the documentation from that same commit. Download and extract its `npm-candidate-…` artifact; GitHub requires sign-in to download artifacts.
+2. Choose the packages for your goal. Replace `VERSION` and the paths with the downloaded filenames:
+
+   **Native UI only** — in your Capacitor 8 app:
+
+   ```sh
+   npm install /path/to/rdlabo-capacitor-native-ui-VERSION.tgz
+   ```
+
+   **Theme only, or theme with Native UI** — install both archives from the same artifact so their versions match:
+
+   ```sh
+   npm install /path/to/rdlabo-capacitor-native-ui-VERSION.tgz /path/to/rdlabo-ionic-theme-ios27-VERSION.tgz
+   ```
+
+   The theme depends on the Native UI package, so its unpublished dependency must also be supplied as an archive. **Theme-only browser apps do not need Capacitor, shell activation, or native sync.** Continue with [theme setup](../theme-ios27/docs/setup.md).
+
+3. For Native UI, continue with the guide for your goal above. Build your Web assets, sync Capacitor and rebuild the native app as described there. The archive install replaces each guide's `npm install` step.
+
+Already using published theme v1.2.1? Its bundled native APIs belong to the old setup. Follow [migration](docs/migration.md) when adopting these candidate packages. The [published documentation](https://docs.rdlabo.dev/projects/ionic-theme-ios27) describes that released version; this directory describes the upcoming split.
+
+## Requirements
+
+Native startup requires Capacitor 8 and an iOS or Android project. Android extensions require API 24+ and Kotlin/Compose. Ordinary native rendering requires iOS 26+ and Xcode 26+. The Ionic adapter supports Ionic `>=8.8.1 <10`; the `/core` HTML adapter requires no Ionic or theme package. [Vertical Bars](docs/vertical-bars.md) and [extension placement](docs/native-ui-extensions.md#content-and-placement-are-independent) have additional device requirements.
+
+For standard controls, follow the setup guide for your markup; the Ionic and HTML adapters use different imports. For custom native content, start directly with the [extensions guide](docs/native-ui-extensions.md).
+
+## Reference and examples
+
+- [Supported Ionic controls](docs/native-ui.md#supported-markup) and fallback behavior.
+- [Configuration](docs/configuration.md): defaults, selected controls, rail-only mode, and live changes.
+- [Vertical Bars](docs/vertical-bars.md): eligibility, appearance, and runtime API.
+- [Now Playing extension](docs/native-mini-player.md): a Web and SwiftUI example to adapt.
+- [Migration](docs/migration.md): package names, imports, and native project updates.

package/RdlaboCapacitorNativeUi.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'RdlaboCapacitorNativeUi'
+  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'
+  s.swift_version = '5.9'
+end

package/android/build.gradle

@@ -0,0 +1,69 @@
+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'
+}
+
+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"
+        classpath "org.jetbrains.kotlin:compose-compiler-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'org.jetbrains.kotlin.plugin.compose'
+
+android {
+    namespace = "dev.rdlabo.capacitor.nativeui"
+    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
+    }
+    buildFeatures { compose true }
+    kotlinOptions { jvmTarget = '21' }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    api platform("androidx.compose:compose-bom:2025.10.00")
+    api "androidx.compose.ui:ui"
+    api "androidx.compose.foundation:foundation"
+    api "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    testImplementation "org.json:json:20250517"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/dev/rdlabo/capacitor/nativeui/NativeUI.kt

@@ -0,0 +1,51 @@
+package dev.rdlabo.capacitor.nativeui
+
+import android.os.Looper
+import androidx.compose.runtime.Composable
+import org.json.JSONObject
+import java.util.Collections
+
+/**
+ * App-local Compose renderers. Register on the main thread before starting the shell.
+ * Experimental API: registration interfaces and behavior may change in future releases.
+ */
+object NativeUI {
+    internal val renderers = linkedMapOf<String, (JSONObject, NativeUIActions, NativeUIContext) -> (@Composable () -> Unit)>()
+
+    fun <Props> register(
+        name: String,
+        decode: (JSONObject) -> Props,
+        content: @Composable (Props, NativeUIActions, NativeUIContext) -> Unit,
+    ) {
+        check(Looper.myLooper() == Looper.getMainLooper()) { "Register Native UI on the main thread" }
+        require(name.isNotBlank() && !renderers.containsKey(name)) { "Native UI names must be nonempty and unique" }
+        renderers[name] = { json, actions, context ->
+            val props = decode(json)
+            val view: @Composable () -> Unit = { content(props, actions, context) }
+            view
+        }
+    }
+}
+
+data class NativeUIFrame(val x: Double, val y: Double, val width: Double, val height: Double)
+
+/** Source geometry, not screen coordinates. Android currently supports element placement only. */
+data class NativeUIContext(
+    val sourceID: String,
+    val sourceFrame: NativeUIFrame,
+    val sourceFrameInDp: NativeUIFrame,
+    val viewportWidth: Double,
+    val dpPerCSSPixel: Double,
+    val dark: Boolean,
+    val rtl: Boolean,
+)
+
+/** Completion acknowledges the DOM click dispatch, not the application's asynchronous work. */
+class NativeUIActions internal constructor(names: Set<String>, private val dispatch: suspend (String) -> Unit) {
+    val availableNames: Set<String> = Collections.unmodifiableSet(names.toSet())
+    fun isAvailable(name: String): Boolean = name in availableNames
+    suspend fun activate(name: String) {
+        check(isAvailable(name)) { "Native UI action is unavailable" }
+        dispatch(name)
+    }
+}

package/android/src/main/java/dev/rdlabo/capacitor/nativeui/NativeUIPlugin.kt

@@ -0,0 +1,192 @@
+package dev.rdlabo.capacitor.nativeui
+
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.platform.ViewCompositionStrategy
+import androidx.compose.ui.unit.LayoutDirection
+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
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.util.UUID
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.math.roundToInt
+
+@CapacitorPlugin(name = "NativeUI")
+class NativeUIPlugin : Plugin() {
+    private val handler = Handler(Looper.getMainLooper())
+    private var host: FrameLayout? = null
+    private var revision = 0L
+    private var sequence = 0L
+    private var paused = false
+    private val entries = linkedMapOf<String, Entry>()
+    private val pending = mutableMapOf<String, (Boolean) -> Unit>()
+    private val layoutListener = View.OnLayoutChangeListener { _, l, t, r, b, oldL, oldT, oldR, oldB ->
+        if (l != oldL || t != oldT || r != oldR || b != oldB) {
+            host?.visibility = View.INVISIBLE
+            failActions()
+            notifyListeners("webViewMetricsChange", JSObject().put("radius", 0))
+        }
+    }
+
+    private class Entry(val view: ComposeView, var node: ExtensionNode) {
+        val content = mutableStateOf<(@Composable () -> Unit)?>(null)
+    }
+
+    override fun load() {
+        activity.runOnUiThread { bridge.webView.addOnLayoutChangeListener(layoutListener) }
+    }
+
+    @PluginMethod
+    fun configure(call: PluginCall) = onMain(call) {
+        clearViews()
+        revision = 0
+        sequence = 0
+        call.resolve(JSObject().put("supported", true).put("extensions", JSArray(NativeUI.renderers.keys.toList())))
+    }
+
+    @PluginMethod
+    fun getWebViewMetrics(call: PluginCall) = call.resolve(JSObject().put("radius", 0))
+
+    @PluginMethod
+    fun update(call: PluginCall) = onMain(call) {
+        val snapshot = NativeUISnapshot.parse(call.data)
+        require(snapshot.revision > revision) { "Stale Native UI snapshot" }
+        val web = bridge.webView
+        val parent = web.parent as? ViewGroup ?: error("WebView has no host")
+        require(web.width > 0 && web.height > 0 && web.scaleX == 1f && web.scaleY == 1f) { "WebView geometry unavailable" }
+        val scale = web.width / snapshot.viewportWidth
+        val dpScale = scale / web.resources.displayMetrics.density
+        val accepted = linkedMapOf<String, Pair<ExtensionNode, @Composable () -> Unit>>()
+        val rejected = snapshot.rejected.toMutableList()
+        for (node in snapshot.nodes) {
+            val renderer = NativeUI.renderers[node.name]
+            if (renderer == null || paused) {
+                rejected.add(node.id)
+                continue
+            }
+            try {
+                val f = node.frame
+                require(listOf(f.x * scale, f.y * scale, f.width * scale, f.height * scale).all { it in -1_000_000.0..1_000_000.0 })
+                val context = NativeUIContext(node.id, f, NativeUIFrame(f.x * dpScale, f.y * dpScale, f.width * dpScale, f.height * dpScale), snapshot.viewportWidth, dpScale, node.dark, node.rtl)
+                val actions = NativeUIActions(node.actions.keys) { action -> activate(node, action) }
+                accepted[node.id] = node to renderer(JSONObject(node.props), actions, context)
+            } catch (_: Exception) {
+                rejected.add(node.id)
+            }
+        }
+        revision = snapshot.revision
+        val container = host ?: FrameLayout(activity).also {
+            it.clipChildren = true
+            it.clipToPadding = true
+            parent.addView(it, ViewGroup.LayoutParams(web.width, web.height))
+            host = it
+        }
+        container.layoutParams = container.layoutParams.apply { width = web.width; height = web.height }
+        container.x = web.x
+        container.y = web.y
+        for (id in entries.keys.toList()) if (id !in accepted) removeEntry(id)
+        for ((id, pair) in accepted) {
+            val (node, content) = pair
+            val entry = entries[id] ?: Entry(ComposeView(activity), node).also { entry ->
+                entry.view.setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
+                container.addView(entry.view)
+                entry.view.setContent { entry.content.value?.invoke() }
+                entries[id] = entry
+            }
+            entry.node = node
+            entry.content.value = {
+                CompositionLocalProvider(LocalLayoutDirection provides if (node.rtl) LayoutDirection.Rtl else LayoutDirection.Ltr) { content() }
+            }
+            entry.view.layoutParams = FrameLayout.LayoutParams((node.frame.width * scale).roundToInt().coerceAtLeast(1), (node.frame.height * scale).roundToInt().coerceAtLeast(1)).apply {
+                leftMargin = (node.frame.x * scale).roundToInt()
+                topMargin = (node.frame.y * scale).roundToInt()
+            }
+        }
+        container.visibility = if (paused) View.INVISIBLE else View.VISIBLE
+        call.resolve(JSObject().put("revision", revision).put("rejectedControls", JSArray(rejected)))
+    }
+
+    private suspend fun activate(node: ExtensionNode, name: String): Unit = withContext(Dispatchers.Main.immediate) {
+        check(!paused && host?.visibility == View.VISIBLE && entries[node.id]?.node == node) { "Native UI action is stale" }
+        val target = node.actions[name] ?: error("Native UI action is unavailable")
+        suspendCancellableCoroutine { continuation ->
+            val request = UUID.randomUUID().toString()
+            val timeout = Runnable { pending.remove(request)?.invoke(false) }
+            pending[request] = { accepted ->
+                handler.removeCallbacks(timeout)
+                if (continuation.isActive) {
+                    if (accepted) continuation.resume(Unit)
+                    else continuation.resumeWithException(IllegalStateException("Native UI action was not accepted"))
+                }
+            }
+            continuation.invokeOnCancellation { handler.post { pending.remove(request); handler.removeCallbacks(timeout) } }
+            handler.postDelayed(timeout, 5000)
+            notifyListeners("activate", JSObject().put("revision", revision).put("id", target).put("sequence", ++sequence).put("requestId", request))
+        }
+    }
+
+    @PluginMethod
+    fun completeExtensionAction(call: PluginCall) = onMain(call) {
+        val request = call.getString("requestId") ?: error("Missing requestId")
+        pending.remove(request)?.invoke(call.getBoolean("accepted", false) == true)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun clear(call: PluginCall) = onMain(call) {
+        val next = call.data.getLong("revision")
+        require(next > revision) { "Stale Native UI clear" }
+        revision = next
+        clearViews()
+        call.resolve()
+    }
+
+    private fun onMain(call: PluginCall, block: () -> Unit) {
+        activity.runOnUiThread {
+            try { block() } catch (error: Exception) { call.reject(error.message ?: "Native UI failed", error) }
+        }
+    }
+    private fun failActions() {
+        val callbacks = pending.values.toList()
+        pending.clear()
+        callbacks.forEach { it(false) }
+    }
+    private fun removeEntry(id: String) {
+        entries.remove(id)?.let { it.view.disposeComposition(); host?.removeView(it.view) }
+    }
+    private fun clearViews() {
+        failActions()
+        entries.keys.toList().forEach(::removeEntry)
+        (host?.parent as? ViewGroup)?.removeView(host)
+        host = null
+    }
+    override fun handleOnPause() {
+        paused = true
+        host?.visibility = View.INVISIBLE
+        failActions()
+    }
+    override fun handleOnResume() {
+        paused = false
+        notifyListeners("webViewMetricsChange", JSObject().put("radius", 0))
+    }
+    override fun handleOnDestroy() {
+        bridge.webView.removeOnLayoutChangeListener(layoutListener)
+        clearViews()
+    }
+}

package/android/src/main/java/dev/rdlabo/capacitor/nativeui/NativeUISnapshot.kt

@@ -0,0 +1,57 @@
+package dev.rdlabo.capacitor.nativeui
+
+import org.json.JSONObject
+
+internal data class ExtensionNode(
+    val id: String,
+    val frame: NativeUIFrame,
+    val dark: Boolean,
+    val rtl: Boolean,
+    val name: String,
+    val props: String,
+    val actions: Map<String, String>,
+)
+
+internal data class NativeUISnapshot(val revision: Long, val viewportWidth: Double, val nodes: List<ExtensionNode>, val rejected: List<String>) {
+    companion object {
+        fun parse(json: JSONObject): NativeUISnapshot {
+            val revisionValue = json.getDouble("revision")
+            require(revisionValue.isFinite() && revisionValue >= 0 && revisionValue % 1.0 == 0.0 && revisionValue <= 9007199254740991.0)
+            val width = json.getDouble("viewportWidth")
+            require(width.isFinite() && width > 0)
+            val controls = json.getJSONArray("controls")
+            require(controls.length() <= 1000)
+            val ids = mutableSetOf<String>()
+            val nodes = mutableListOf<ExtensionNode>()
+            val rejected = mutableListOf<String>()
+            for (index in 0 until controls.length()) {
+                val item = controls.getJSONObject(index)
+                val id = item.getString("id")
+                require(id.isNotBlank() && ids.add(id))
+                if (item.getString("kind") != "extension") {
+                    rejected.add(id)
+                    continue
+                }
+                val extension = item.getJSONObject("extension")
+                if (!extension.isNull("tabBarId") || item.optString("placement") == "vertical-bars") {
+                    rejected.add(id)
+                    continue
+                }
+                val frame = NativeUIFrame(item.getDouble("x"), item.getDouble("y"), item.getDouble("width"), item.getDouble("height"))
+                require(listOf(frame.x, frame.y, frame.width, frame.height).all { it.isFinite() })
+                require(frame.width > 0 && frame.height > 0)
+                val props = extension.getString("props")
+                require(props.length <= 65536)
+                JSONObject(props)
+                val rawActions = extension.getJSONObject("actions")
+                require(rawActions.length() <= 30)
+                val actions = rawActions.keys().asSequence().associateWith { key ->
+                    require(key.isNotBlank())
+                    rawActions.getString(key).also { require(it.isNotBlank()) }
+                }
+                nodes.add(ExtensionNode(id, frame, item.optBoolean("dark"), item.optBoolean("rtl"), extension.getString("name"), props, actions))
+            }
+            return NativeUISnapshot(revisionValue.toLong(), width, nodes, rejected)
+        }
+    }
+}

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/core.d.ts

@@ -0,0 +1,4 @@
+import { NativeUIExtension, NativeUIImageReference, NativeUIReadContext, NativeUIValue, defineNativeUI } from "./native/extensions.js";
+import { AutoIonicControls, IonicProjectionOptions, NativeUIControls, NativeUIHandle, NativeUIOptions, NativeUIStatus, NativeUISuspension, NativeUIVerticalBarsOptions, ToolbarProjectionOptions } from "./native/definitions.js";
+import { enableNativeUI } from "./native/startup.js";
+export { type AutoIonicControls, type IonicProjectionOptions, type NativeUIControls, type NativeUIExtension, type NativeUIHandle, type NativeUIImageReference, type NativeUIOptions, type NativeUIReadContext, type NativeUIStatus, type NativeUISuspension, type NativeUIValue, type NativeUIVerticalBarsOptions, type ToolbarProjectionOptions, defineNativeUI, enableNativeUI };

package/dist/core.js

@@ -0,0 +1,3 @@
+import { defineNativeUI } from "./native/extensions.js";
+import { enableNativeUI } from "./native/startup.js";
+export { defineNativeUI, enableNativeUI };

package/dist/native/activation.d.ts

@@ -0,0 +1,14 @@
+import { NativeUIExtension, NativeUIValue, defineNativeUI } from "./extensions.js";
+import { NativeUIComponent, NativeUIControls, NativeUIPlugin, NativeUIRuntimeHandle, NativeUIRuntimeOptions, NativeUIStatus, NativeUISuspension, VerticalBarEdge, WebViewMetrics } from "./definitions.js";
+//#region src/native/activation.d.ts
+interface OverlayController {
+  suspend(): Promise<() => void>;
+  destroy(): Promise<void>;
+}
+type OverlayFactory = (doc: Document, plugin: NativeUIPlugin, options: NativeUIRuntimeOptions, retain: (deferActivation?: (id: string) => boolean) => () => void, nativeRail: () => boolean) => Promise<OverlayController>;
+export declare const NativeUI: NativeUIPlugin;
+export declare const configureNativeTransition: () => Promise<WebViewMetrics>;
+export declare const enableNativeUI: (options?: NativeUIRuntimeOptions, overlayFactory?: OverlayFactory) => Promise<NativeUIRuntimeHandle>;
+//#endregion
+export { type NativeUIComponent, type NativeUIControls, type NativeUIExtension, type NativeUIRuntimeHandle, type NativeUIRuntimeOptions, type NativeUIStatus, type NativeUISuspension, type NativeUIValue, type VerticalBarEdge, type WebViewMetrics, defineNativeUI };
+//# sourceMappingURL=activation.d.ts.map

package/dist/native/activation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activation.d.ts","names":[],"sources":["../../src/native/activation.ts"],"mappings":";;;UASU;EACR,WAAW;EACX,WAAW;;KAER,kBACH,KAAK,UACL,QAAQ,gBACR,SAAS,wBACT,SAAS,mBAAmB,uCAC5B,8BACG,QAAQ;qBAkBA,UAAQ;qBAqGR,iCAAsC,QAAQ;qBAuB9C,iBAAkB,UAAS,wBAA6B,iBAAiB,mBAAiB,QAAQ"}