akanjs 3.0.0-beta.9 → 3.0.1

package/vendor/@akanjs/native/plugins/preferences/src/web.ts

@@ -0,0 +1,55 @@
+import { AkanNativeError, defineWebPlugin } from "../../../packages/core/src/index.ts";
+import type { PreferencesApi } from "./index.ts";
+
+const PREFIX = "akan-native.preferences.";
+
+function storage(): Storage {
+  try {
+    return window.localStorage;
+  } catch (error) {
+    
+    throw new AkanNativeError("UNSUPPORTED", "localStorage is not available", { cause: error });
+  }
+}
+
+function checkKey(key: unknown): string {
+  if (typeof key !== "string" || key.length === 0)
+    throw new AkanNativeError("INVALID_ARGS", "key must be a non-empty string");
+  return key;
+}
+
+function ownKeys(store: Storage): string[] {
+  const keys: string[] = [];
+  for (let i = 0; i < store.length; i++) {
+    const key = store.key(i);
+    if (key?.startsWith(PREFIX)) keys.push(key);
+  }
+  return keys;
+}
+
+export const web = defineWebPlugin<PreferencesApi>({
+  methods: {
+    async get(args) {
+      return { value: storage().getItem(PREFIX + checkKey(args?.key)) };
+    },
+    async set(args) {
+      const key = checkKey(args?.key);
+      if (typeof args.value !== "string") throw new AkanNativeError("INVALID_ARGS", "value must be a string");
+      try {
+        storage().setItem(PREFIX + key, args.value);
+      } catch (error) {
+        throw new AkanNativeError("INTERNAL", `could not store ${key}: ${String(error)}`, { cause: error });
+      }
+    },
+    async remove(args) {
+      storage().removeItem(PREFIX + checkKey(args?.key));
+    },
+    async keys() {
+      return { keys: ownKeys(storage()).map((k) => k.slice(PREFIX.length)) };
+    },
+    async clear() {
+      const store = storage();
+      for (const key of ownKeys(store)) store.removeItem(key);
+    },
+  },
+});

package/vendor/@akanjs/native/plugins/push/android/AkanNativeMessagingService.kt

@@ -0,0 +1,17 @@
+package com.akanjs.plugins.push
+
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+
+/**
+ * FCM's entry point for this app (declared in the push plugin's manifest; the library's own service has
+ * a lower priority). Firebase calls it on its own thread, also when no activity runs; the plugin gets
+ * the token and the messages when it exists (PushPlugin.Router).
+ */
+class AkanNativeMessagingService : FirebaseMessagingService() {
+    @Suppress("OVERRIDE_DEPRECATION")
+    override fun onNewToken(token: String) = PushPlugin.Router.token(token)
+
+    /** Data messages always; notification messages only while the app is in front (Firebase shows them otherwise). */
+    override fun onMessageReceived(message: RemoteMessage) = PushPlugin.Router.message(this, message)
+}

package/vendor/@akanjs/native/plugins/push/android/PushPlugin.kt

@@ -0,0 +1,265 @@
+package com.akanjs.plugins.push
+
+import android.Manifest
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.google.firebase.FirebaseApp
+import com.google.firebase.messaging.FirebaseMessaging
+import com.google.firebase.messaging.RemoteMessage
+import com.akanjs.runtime.AkanNativeErrorCode
+import com.akanjs.runtime.AkanNativePermission
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+import com.akanjs.runtime.AkanNativeVoidReply
+import java.lang.ref.WeakReference
+
+/**
+ * Remote notifications through Firebase Cloud Messaging (akanjs readiness O6-2), the opt-in module:
+ * its closure (native/android/maven.lock.json) goes only into apps with this plugin, and the app's
+ * google-services.json becomes the string resources Firebase initializes from (android.googleServices).
+ * - register(): FirebaseMessaging.token; AkanNativeMessagingService.onNewToken reports later changes.
+ * - A notification message is shown by Firebase while the app is in the background; its tap starts
+ *   the activity with the message in the intent extras (google.message_id), which is an "action"
+ *   (capacitor-plugins-next PushNotificationsPlugin.java handleOnNewIntent). The launch tap waits for
+ *   the first listener (C2).
+ * - In front, onMessageReceived gets every message: "received", and with setForegroundPresentation a
+ *   notification of our own whose tap works the same way.
+ * - POST_NOTIFICATIONS is asked for on Android 13+; before, notifications are allowed unless turned off.
+ */
+class PushPlugin(private val context: AkanNativePluginContext) : PushPluginSpec {
+    private val app = context.activity.applicationContext
+    private val events = PushEvents(context)
+    private val manager = app.getSystemService(NotificationManager::class.java)
+    private val listening = HashSet<String>()
+
+    /** push.android from the app config (N13), as the build put it into the manifest's meta-data. */
+    @Suppress("DEPRECATION") // getApplicationInfo(String, ApplicationInfoFlags) is API 33+
+    private val meta: Bundle = try {
+        app.packageManager.getApplicationInfo(app.packageName, PackageManager.GET_META_DATA).metaData ?: Bundle()
+    } catch (e: PackageManager.NameNotFoundException) {
+        Bundle()
+    }
+    private val channelId: String = meta.getString("com.google.firebase.messaging.default_notification_channel_id") ?: CHANNEL
+    private val smallIcon: Int = meta.getInt("com.google.firebase.messaging.default_notification_icon").takeIf { it != 0 }
+        ?: app.applicationInfo.icon.takeIf { it != 0 } ?: android.R.drawable.ic_dialog_info
+    private val color: Int? = meta.getInt("com.google.firebase.messaging.default_notification_color").takeIf { it != 0 }?.let { runCatching { app.getColor(it) }.getOrNull() }
+
+    init {
+        Router.plugin = WeakReference(this)
+        tapOf(context.activity.intent)?.let(Router.pendingActions::add)
+        createConfiguredChannel()
+    }
+
+    /**
+     * The app's channel, made at startup: Firebase posts background notifications into the default
+     * channel only when it exists (else into its own "Miscellaneous" one). Settings users changed stay.
+     */
+    private fun createConfiguredChannel() {
+        val name = meta.getString("com.akanjs.push.channel_name") ?: return
+        val importance = when (meta.getString("com.akanjs.push.channel_importance")) {
+            "min" -> NotificationManager.IMPORTANCE_MIN
+            "low" -> NotificationManager.IMPORTANCE_LOW
+            "high" -> NotificationManager.IMPORTANCE_HIGH
+            else -> NotificationManager.IMPORTANCE_DEFAULT
+        }
+        val channel = NotificationChannel(channelId, name, importance)
+        meta.getString("com.akanjs.push.channel_description")?.let { channel.description = it }
+        manager.createNotificationChannel(channel) // renames an existing one; its importance stays the user's
+    }
+
+    override fun destroy() {
+        if (Router.plugin?.get() === this) Router.plugin = null
+    }
+
+    // ------------------------------------------------------------ permission
+
+    override fun checkPermission(reply: AkanNativeReply<PushCheckPermissionResult>) = reply.resolve(PushCheckPermissionResult(display = display()))
+
+    override fun requestPermission(reply: AkanNativeReply<PushRequestPermissionResult>) {
+        val state = display()
+        if (Build.VERSION.SDK_INT < 33 || state == PushPermissionState.GRANTED || state == PushPermissionState.DENIED) {
+            return reply.resolve(PushRequestPermissionResult(display = state))
+        }
+        context.requestPermissions(arrayOf(Manifest.permission.POST_NOTIFICATIONS)) { reply.resolve(PushRequestPermissionResult(display = display())) }
+    }
+
+    private fun display(): PushPermissionState {
+        if (manager.areNotificationsEnabled()) return PushPermissionState.GRANTED
+        if (Build.VERSION.SDK_INT < 33) return PushPermissionState.DENIED // turned off in the settings
+        val state = context.permissionState(Manifest.permission.POST_NOTIFICATIONS)
+        if (state == AkanNativePermission.GRANTED) return PushPermissionState.DENIED
+        return PushPermissionState.entries.first { it.json == state }
+    }
+
+    // ------------------------------------------------------------ registration
+
+    private fun messaging(reply: AkanNativeReply<*>): FirebaseMessaging? {
+        if (FirebaseApp.getApps(app).isEmpty()) {
+            reply.reject(AkanNativeErrorCode.UNSUPPORTED, "Firebase is not set up: add the Firebase project's google-services.json as android.googleServices in akan-native.config")
+            return null
+        }
+        return FirebaseMessaging.getInstance()
+    }
+
+    override fun register(reply: AkanNativeReply<PushToken>) {
+        val messaging = messaging(reply) ?: return
+        messaging.isAutoInitEnabled = true
+        @Suppress("DEPRECATION") // the Task API; the suspending one is in kotlinx-coroutines-play-services
+        messaging.token.addOnCompleteListener { task ->
+            // task.result throws when the task failed (an invalid API key is an IllegalArgumentException).
+            val token = if (task.isSuccessful) task.result else null
+            if (token == null) {
+                val error = task.exception
+                // A bad google-services.json or a device without Play services cannot register at all;
+                // anything else (SERVICE_NOT_AVAILABLE: offline, throttled) may work later.
+                val permanent = error is IllegalArgumentException || error?.message?.contains("MISSING_INSTANCEID_SERVICE") == true
+                return@addOnCompleteListener reply.reject(if (permanent) AkanNativeErrorCode.UNSUPPORTED else AkanNativeErrorCode.INTERNAL, "FCM registration failed: ${error?.message ?: "no token"}")
+            }
+            Router.lastToken = token
+            reply.resolve(PushToken(token = token, provider = PushProvider.FCM, platform = PushTokenPlatform.ANDROID))
+        }
+    }
+
+    override fun unregister(reply: AkanNativeVoidReply) {
+        val messaging = messaging(reply) ?: return
+        messaging.isAutoInitEnabled = false
+        @Suppress("DEPRECATION")
+        messaging.deleteToken().addOnCompleteListener { task ->
+            Router.lastToken = null
+            if (task.isSuccessful) reply.resolve() else reply.reject(AkanNativeErrorCode.INTERNAL, task.exception?.message ?: "deleteToken failed")
+        }
+    }
+
+    override fun setForegroundPresentation(args: PushPresentation, reply: AkanNativeVoidReply) {
+        Router.showInFront = args.banner == true || args.list == true
+        Router.soundInFront = args.sound == true
+        Router.except = args.except
+        reply.resolve()
+    }
+
+    // ------------------------------------------------------------ events
+
+    override fun onNewIntent(intent: Intent) {
+        val action = tapOf(intent) ?: return
+        if ("action" in listening) events.action(action) else Router.pendingActions.add(action)
+    }
+
+    override fun startListening(event: String) {
+        listening.add(event)
+        if (event == "action") {
+            for (action in Router.pendingActions) events.action(action)
+            Router.pendingActions.clear()
+        }
+        // A token that changed while no page listened goes to the first listener (C2), the latest only.
+        if (event == "token") Router.pendingToken?.let { Router.pendingToken = null; tokenChanged(it) }
+    }
+
+    override fun stopListening(event: String) {
+        listening.remove(event)
+    }
+
+    private fun tokenChanged(token: String) {
+        if ("token" in listening) events.token(PushToken(token = token, provider = PushProvider.FCM, platform = PushTokenPlatform.ANDROID))
+        else Router.pendingToken = token
+    }
+
+    private fun received(message: RemoteMessage) {
+        val notification = message.notification
+        if ("received" in listening) events.received(PushMessage(id = message.messageId, title = notification?.title, body = notification?.body, data = message.data))
+        if (notification != null && Router.showInFront && !Router.excepted(message.data)) showInFront(message, notification)
+    }
+
+    /** A notification for a message that arrived in front, when the page asked for one; its tap is an "action". */
+    private fun showInFront(message: RemoteMessage, notification: RemoteMessage.Notification) {
+        val channel = notification.channelId ?: channelId
+        if (manager.getNotificationChannel(channel) == null) {
+            manager.createNotificationChannel(NotificationChannel(channel, "Notifications", if (Router.soundInFront) NotificationManager.IMPORTANCE_DEFAULT else NotificationManager.IMPORTANCE_LOW))
+        }
+        val tap = app.packageManager.getLaunchIntentForPackage(app.packageName)?.apply {
+            addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+            putExtra(MESSAGE_ID, message.messageId ?: "")
+            for ((key, value) in message.data) putExtra(key, value)
+            notification.title?.let { putExtra(TITLE, it) }
+            notification.body?.let { putExtra(BODY, it) }
+        } ?: return
+        val pending = PendingIntent.getActivity(app, (message.messageId ?: "").hashCode(), tap, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
+        val builder = android.app.Notification.Builder(app, channel)
+            .setContentTitle(notification.title)
+            .setContentText(notification.body)
+            .setSmallIcon(smallIcon)
+            .setAutoCancel(true)
+            .setContentIntent(pending)
+        color?.let(builder::setColor)
+        val built = builder.build()
+        try {
+            manager.notify((message.messageId ?: System.currentTimeMillis().toString()).hashCode(), built)
+        } catch (e: SecurityException) { // POST_NOTIFICATIONS was taken back
+            Log.w("AkanNative", "push: cannot show a notification", e)
+        }
+    }
+
+    /** The message a notification tap carries in the activity's intent, or null. */
+    private fun tapOf(intent: Intent?): PushAction? {
+        val extras: Bundle = intent?.extras ?: return null
+        if (!extras.containsKey(MESSAGE_ID)) return null
+        val data = HashMap<String, Any>()
+        for (key in extras.keySet()) {
+            if (key == MESSAGE_ID || key == TITLE || key == BODY || key.startsWith("google.") || key.startsWith("gcm.") || key == "from" || key == "collapse_key") continue
+            @Suppress("DEPRECATION") val value = extras.get(key) ?: continue
+            data[key] = value as? String ?: value.toString()
+        }
+        val message = PushMessage(id = extras.getString(MESSAGE_ID), title = extras.getString(TITLE), body = extras.getString(BODY), data = data)
+        intent.removeExtra(MESSAGE_ID) // an activity made again from the same intent brings no second tap
+        return PushAction(actionId = "tap", message = message)
+    }
+
+    /** What the FCM service and the plugin share: the service runs without an activity. Main thread. */
+    object Router {
+        var plugin: WeakReference<PushPlugin>? = null
+        /** Taps before the page listened (C2), the process's. */
+        val pendingActions = ArrayList<PushAction>()
+        var lastToken: String? = null
+        /** A token change no page heard yet (delivered on the first "token" listener). */
+        var pendingToken: String? = null
+        var showInFront = false
+        var soundInFront = false
+        var except: PushPresentationExcept? = null
+
+        fun excepted(data: Map<String, String>): Boolean {
+            val rule = except ?: return false
+            val value = data[rule.key] ?: return false
+            return value in rule.values
+        }
+        private val main = Handler(Looper.getMainLooper())
+
+        fun token(token: String) {
+            main.post {
+                if (token != lastToken) plugin?.get()?.tokenChanged(token) ?: run { if (lastToken != null) pendingToken = token }
+                lastToken = token
+            }
+        }
+
+        fun message(context: Context, message: RemoteMessage) {
+            main.post {
+                val target = plugin?.get()
+                if (target != null) target.received(message) else Log.i("AkanNative", "push: message ${message.messageId} arrived without a page")
+            }
+        }
+    }
+
+    private companion object {
+        const val MESSAGE_ID = "google.message_id"
+        const val TITLE = "akan-native.push.title"
+        const val BODY = "akan-native.push.body"
+        const val CHANNEL = "akan_native_push"
+    }
+}

package/vendor/@akanjs/native/plugins/push/ios/PushPlugin.swift

@@ -0,0 +1,173 @@
+import UIKit
+import UserNotifications
+
+/// Remote notifications through APNs directly (akanjs readiness O6-2), no Firebase SDK.
+/// - register(): UIApplication.registerForRemoteNotifications; the app delegate hands the result to
+///   AkanNativeRemoteNotifications, and the device token goes to the page as hex (what APNs senders take,
+///   capacitor-plugins-next PushNotificationsPlugin.swift). A later, different token is a "token" event.
+/// - Taps and foreground deliveries come through the shell's notification router (AkanNativeNotifications,
+///   plugins.md C5): a remote notification is one whose trigger is UNPushNotificationTrigger, so the
+///   local-notifications plugin keeps its own. The tap that launched the app waits in the router until
+///   the page listens for "action" (C2).
+/// - Foreground presentation follows setForegroundPresentation (default: not shown, like iOS without a
+///   delegate); the page always gets "received".
+/// - Silent pushes (content-available) reach the page as "received" while it listens.
+/// - aps-environment comes from the manifest ("development"); an iPhone build takes the provisioning
+///   profile's value (ios.ts), so App Store builds say "production".
+final class PushPlugin: PushPluginSpec {
+    static let id = "push"
+    private let context: AkanNativePluginContext
+    private lazy var events = PushEvents(context)
+    private var presentation: UNNotificationPresentationOptions = []
+    private var except: PushPresentationExcept?
+    private var waiting: [AkanNativeReply<PushToken>] = []
+    private var lastToken: String?
+    /// A token change no page heard yet: delivered to the first "token" listener (C2), the latest only.
+    private var pendingToken: PushToken?
+    private var listening: Set<String> = []
+
+    init(context: AkanNativePluginContext) {
+        self.context = context
+        if case .success(let data) = AkanNativeRemoteNotifications.shared.lastRegistration { lastToken = Self.hex(data) }
+        AkanNativeRemoteNotifications.shared.listen(owner: context.owner, registration: { [weak self] result in self?.registered(result) }) { [weak self] userInfo in
+            guard let self, self.listening.contains("received") else { return false }
+            self.events.received(PushMessage(id: nil, title: nil, body: nil, data: Self.data(userInfo)))
+            return true
+        }
+        AkanNativeNotifications.shared.register(Self.id, owner: context.owner, AkanNativeNotifications.Handler(
+            claims: { $0.trigger is UNPushNotificationTrigger },
+            willPresent: { [weak self] notification in
+                guard let self else { return [] }
+                self.events.received(Self.message(notification.request))
+                if let except = self.except, let value = notification.request.content.userInfo[except.key] as? String,
+                   except.values.contains(value) { return [] }
+                return self.presentation
+            },
+            didReceive: { [weak self] response in
+                guard let self, self.listening.contains("action") else { return false }
+                let id = response.actionIdentifier
+                let actionId = id == UNNotificationDefaultActionIdentifier ? "tap" : id == UNNotificationDismissActionIdentifier ? "dismiss" : id
+                self.events.action(PushAction(actionId: actionId, message: Self.message(response.notification.request)))
+                return true
+            }
+        ))
+    }
+
+    // MARK: permission
+
+    func checkPermission(_ reply: AkanNativeReply<PushCheckPermissionResult>) {
+        UNUserNotificationCenter.current().getNotificationSettings { settings in
+            let state = Self.state(settings.authorizationStatus)
+            DispatchQueue.main.async { reply.resolve(PushCheckPermissionResult(display: state)) }
+        }
+    }
+
+    func requestPermission(_ reply: AkanNativeReply<PushRequestPermissionResult>) {
+        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { _, error in
+            UNUserNotificationCenter.current().getNotificationSettings { settings in
+                let state = Self.state(settings.authorizationStatus)
+                DispatchQueue.main.async {
+                    if let error, state != .granted { return reply.reject(.internalError, error.localizedDescription) }
+                    reply.resolve(PushRequestPermissionResult(display: state))
+                }
+            }
+        }
+    }
+
+    nonisolated private static func state(_ status: UNAuthorizationStatus) -> PushPermissionState {
+        switch status {
+        case .authorized, .provisional, .ephemeral: .granted
+        case .denied: .denied
+        default: .prompt
+        }
+    }
+
+    // MARK: registration
+
+    func register(_ reply: AkanNativeReply<PushToken>) {
+        waiting.append(reply)
+        // Every call asks again: iOS answers with the current token (and a new one after a restore).
+        UIApplication.shared.registerForRemoteNotifications()
+    }
+
+    func unregister(_ reply: AkanNativeReply<Void>) {
+        UIApplication.shared.unregisterForRemoteNotifications()
+        lastToken = nil
+        reply.resolve()
+    }
+
+    private func registered(_ result: Result<Data, any Error>) {
+        let replies = waiting
+        waiting = []
+        switch result {
+        case .success(let data):
+            let token = PushToken(token: Self.hex(data), provider: .apns, platform: .ios)
+            for reply in replies { reply.resolve(token) }
+            if let previous = lastToken, previous != token.token {
+                if listening.contains("token") { events.token(token) } else { pendingToken = token }
+            }
+            lastToken = token.token
+        case .failure(let error):
+            // The simulator and a missing aps-environment entitlement end here.
+            for reply in replies { reply.reject(.unsupported, "APNs registration failed: \(error.localizedDescription)") }
+        }
+    }
+
+    func setForegroundPresentation(_ args: PushPresentation, _ reply: AkanNativeReply<Void>) {
+        var options: UNNotificationPresentationOptions = []
+        if args.banner == true { options.insert(.banner) }
+        if args.list == true { options.insert(.list) }
+        if args.sound == true { options.insert(.sound) }
+        if args.badge == true { options.insert(.badge) }
+        presentation = options
+        except = args.except
+        reply.resolve()
+    }
+
+    // MARK: events
+
+    func startListening(_ event: String) {
+        listening.insert(event)
+        if event == "action" { AkanNativeNotifications.shared.replay(Self.id) }
+        if event == "token", let token = pendingToken {
+            pendingToken = nil
+            events.token(token)
+        }
+    }
+
+    func stopListening(_ event: String) {
+        listening.remove(event)
+    }
+
+    // MARK: JSON
+
+    nonisolated private static func hex(_ data: Data) -> String {
+        data.map { String(format: "%02x", $0) }.joined()
+    }
+
+    private static func message(_ request: UNNotificationRequest) -> PushMessage {
+        let content = request.content
+        return PushMessage(id: request.identifier, title: content.title.isEmpty ? nil : content.title, body: content.body.isEmpty ? nil : content.body, data: data(content.userInfo))
+    }
+
+    /// The payload's own keys (not "aps"), as JSON values.
+    private static func data(_ userInfo: [AnyHashable: Any]) -> [String: Any] {
+        var out: [String: Any] = [:]
+        for (key, value) in userInfo {
+            guard let key = key as? String, key != "aps" else { continue }
+            out[key] = json(value)
+        }
+        return out
+    }
+
+    private static func json(_ value: Any) -> Any {
+        switch value {
+        case let v as String: v
+        case let v as NSNumber: v
+        case let v as [Any]: v.map(json)
+        case let v as [AnyHashable: Any]: Dictionary(uniqueKeysWithValues: v.compactMap { k, x in (k as? String).map { ($0, json(x)) } })
+        case is NSNull: NSNull()
+        default: String(describing: value)
+        }
+    }
+}

package/vendor/@akanjs/native/plugins/push/native-plugin.json

@@ -0,0 +1,23 @@
+{
+  "id": "push",
+  "apiVersion": 1,
+  "methods": ["checkPermission", "requestPermission", "register", "unregister", "setForegroundPresentation"],
+  "events": ["token", "received", "action"],
+  "codegen": true,
+  "web": null,
+  "desktop": null,
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "PushPlugin",
+    "frameworks": ["UserNotifications"],
+    "infoPlist": { "UIBackgroundModes": ["remote-notification"] },
+    "entitlements": { "aps-environment": "development" }
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.push.PushPlugin",
+    "maven": ["com.google.firebase:firebase-messaging:25.1.3", "androidx.core:core:1.10.0"],
+    "permissions": ["android.permission.POST_NOTIFICATIONS"],
+    "applicationXml": "<service android:name=\"com.akanjs.plugins.push.AkanNativeMessagingService\" android:exported=\"false\"><intent-filter><action android:name=\"com.google.firebase.MESSAGING_EVENT\" /></intent-filter></service>"
+  }
+}

package/vendor/@akanjs/native/plugins/push/src/index.ts

@@ -0,0 +1,83 @@
+import { definePlugin } from "../../../packages/core/src/index.ts";
+import { usePluginEvent } from "../../../packages/react/src/index.ts";
+
+/** C1 permission states. Android reports "prompt-with-rationale" after one refusal. */
+export type PushPermissionState = "granted" | "denied" | "prompt" | "prompt-with-rationale";
+
+export type PushProvider = "apns" | "fcm";
+
+/** Where the server sends: an APNs device token (hex) or an FCM registration token. */
+export interface PushToken {
+  token: string;
+  provider: PushProvider;
+  platform: "ios" | "android";
+}
+
+export interface PushMessage {
+  /** APNs: the notification's request identifier. FCM: the message id. */
+  id?: string;
+  title?: string;
+  body?: string;
+  /** The payload's own keys: APNs userInfo without "aps", FCM data. */
+  data: Record<string, unknown>;
+}
+
+export interface PushAction {
+  /** "tap" for the notification itself, else the action's identifier. */
+  actionId: string;
+  message: PushMessage;
+}
+
+/** How a push that arrives while the app is in front is shown. Default: not shown (the page gets "received"). */
+export interface PushPresentation {
+  banner?: boolean;
+  list?: boolean;
+  sound?: boolean;
+  badge?: boolean;
+  /**
+   * Not shown when its `data[key]` is one of `values`, e.g. the chat room on screen: `{ key: "url", values: [path] }`.
+   * It still arrives as "received".
+   */
+  except?: PushPresentationExcept;
+}
+
+export interface PushPresentationExcept {
+  key: string;
+  values: string[];
+}
+
+export interface PushApi {
+  checkPermission(): Promise<{ display: PushPermissionState }>;
+  /** Asks for permission to show notifications (Android 13+ and iOS; granted earlier on older Android). */
+  requestPermission(): Promise<{ display: PushPermissionState }>;
+  /** Registers with APNs or FCM; resolves with the token. A later change arrives as "token". */
+  register(): Promise<PushToken>;
+  /** Stops pushes to this installation (APNs unregister; FCM deletes the token). */
+  unregister(): Promise<void>;
+  setForegroundPresentation(args: PushPresentation): Promise<void>;
+}
+
+export interface PushEvents {
+  /**
+   * The token changed (FCM refreshes it; APNs after a restore). Send it to the server again. A change
+   * while no page listened is kept (the latest) and goes to the first listener.
+   */
+  token: PushToken;
+  /** A push arrived while the app runs (shown or not, per setForegroundPresentation). */
+  received: PushMessage;
+  /** The user tapped a push. The tap that launched the app is kept until the first listener. */
+  action: PushAction;
+}
+
+export const push = definePlugin<PushApi, PushEvents>("push", {
+  methods: ["checkPermission", "requestPermission", "register", "unregister", "setForegroundPresentation"],
+  events: ["token", "received", "action"],
+});
+
+/** Subscribes to a push event for the component's lifetime. */
+export function usePushEvent<E extends keyof PushEvents & string>(
+  event: E,
+  handler: (data: PushEvents[E]) => void,
+): void {
+  usePluginEvent(push, event, handler);
+}

package/vendor/@akanjs/native/plugins/screen/native-plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "screen",
+  "apiVersion": 1,
+  "methods": ["getDisplays", "getCursorPoint"],
+  "events": ["change"],
+  "web": "./src/web.ts",
+  "desktop": "./src/desktop.ts",
+  "ios": null,
+  "android": null
+}