akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/plugins/secure-storage/src/index.ts

@@ -0,0 +1,33 @@
+import { definePlugin } from "../../../packages/core/src/index.ts";
+
+/**
+ * Small secrets (tokens, keys, passwords) kept by the OS credential store, encrypted at rest.
+ * Same shape as @akanjs/native/plugins/preferences; store JSON yourself for structured data.
+ *
+ * - iOS: Keychain generic passwords, readable after the first unlock, never synced or restored
+ *   to another device. Keychain items survive uninstalling the app.
+ * - Android: values encrypted with an AES-256-GCM key that never leaves AndroidKeyStore.
+ *   Uninstalling deletes them; values whose key is gone (device transfer) read as null.
+ * - macOS: values encrypted with a key kept in the login Keychain (see src/desktop.ts for
+ *   what that protects against).
+ * - Windows: the same, with the key in the Credential Manager (a generic credential).
+ * - Linux: the same, with the key in the Secret Service (the login keyring of gnome-keyring,
+ *   KWallet or KeePassXC). UNSUPPORTED in a session without one.
+ * - Web: UNSUPPORTED. A browser has no secret store; do not fall back to localStorage.
+ *
+ * No hook on purpose: secrets are read where they are used (an API client), not rendered.
+ */
+export interface SecureStorageApi {
+  /** `{ value: null }` when the key is not stored. */
+  get(args: { key: string }): Promise<{ value: string | null }>;
+  set(args: { key: string; value: string }): Promise<void>;
+  remove(args: { key: string }): Promise<void>;
+  /** Stored keys, sorted. */
+  keys(): Promise<{ keys: string[] }>;
+  /** Removes every key of this app. */
+  clear(): Promise<void>;
+}
+
+export const secureStorage = definePlugin<SecureStorageApi>("secure-storage", {
+  methods: ["get", "set", "remove", "keys", "clear"],
+});

package/vendor/@akanjs/native/plugins/share/android/SharePlugin.kt

@@ -0,0 +1,218 @@
+package com.akanjs.plugins.share
+
+import android.app.Activity
+import android.app.Application
+import android.app.PendingIntent
+import android.content.ActivityNotFoundException
+import android.content.BroadcastReceiver
+import android.content.ClipData
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+import com.akanjs.runtime.AkanNativeCall
+import com.akanjs.runtime.AkanNativeCompat
+import com.akanjs.runtime.AkanNativeErrorCode
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+import java.io.File
+import java.util.UUID
+import org.json.JSONObject
+
+/**
+ * ACTION_SEND / ACTION_SEND_MULTIPLE through Intent.createChooser.
+ * - Which app was chosen comes back through the chooser's IntentSender
+ *   (capacitor-plugins/share/…/SharePlugin.java:141-161). Capacitor registers an exported receiver
+ *   and checks a nonce; here the PendingIntent is explicit (setPackage) and the receiver is
+ *   RECEIVER_NOT_EXPORTED, so only broadcasts sent as this app arrive. FLAG_MUTABLE lets the chooser
+ *   fill in EXTRA_CHOSEN_COMPONENT; Android 14 allows that because the intent is explicit.
+ * - Targets often answer RESULT_CANCELED even after sharing, so completed = a target was chosen, or
+ *   the activity went through onStop (the target covered it), or RESULT_OK (:76-87, :215-219).
+ *   react-native ShareModule.kt:37-54 cannot tell a closed sheet at all.
+ * - title → EXTRA_SUBJECT (mail) and EXTRA_TITLE (the sheet's preview title). The intent has one text
+ *   field, so url is appended to text (Capacitor :117-126).
+ * - Files need a content:// URI in the shell's own provider (plugins.md C4), a read grant, and
+ *   ClipData even for a single file: the grant only reaches the target through ClipData (:192-200).
+ * Arguments arrive decoded and type-checked by the generated SharePluginSpec (PL-10).
+ */
+class SharePlugin(private val context: AkanNativePluginContext) : SharePluginSpec {
+    /**
+     * canShare answers false for options it cannot decode instead of rejecting (src/index.ts, as
+     * navigator.canShare does); everything else goes through the generated dispatch.
+     */
+    override fun handle(call: AkanNativeCall) {
+        if (call.method == "canShare" && runCatching { ShareOptions.fromAkanNative(call.args, "") }.isFailure) {
+            return call.resolve(JSONObject().put("value", false))
+        }
+        akanNativeDispatch(call)
+    }
+
+    private class Pending(val reply: AkanNativeReply<ShareResult>, val nonce: String) {
+        var target: String? = null
+        var stopped = false
+    }
+
+    private val activity: Activity get() = context.activity
+    private val action = context.activity.packageName + ".akan-native.share.CHOSEN"
+    private var pending: Pending? = null
+
+    private val receiver = object : BroadcastReceiver() {
+        override fun onReceive(c: Context, intent: Intent) {
+            val p = pending ?: return
+            if (intent.getStringExtra(EXTRA_NONCE) != p.nonce) return // a late broadcast from an earlier share
+            val chosen = AkanNativeCompat.parcelableExtra(intent, Intent.EXTRA_CHOSEN_COMPONENT, ComponentName::class.java) ?: return
+            p.target = chosen.packageName
+        }
+    }
+
+    private val lifecycle = object : Application.ActivityLifecycleCallbacks {
+        override fun onActivityStopped(a: Activity) {
+            pending?.stopped = true
+        }
+        override fun onActivityCreated(a: Activity, state: Bundle?) {}
+        override fun onActivityStarted(a: Activity) {}
+        override fun onActivityResumed(a: Activity) {}
+        override fun onActivityPaused(a: Activity) {}
+        override fun onActivitySaveInstanceState(a: Activity, state: Bundle) {}
+        override fun onActivityDestroyed(a: Activity) {}
+    }
+
+    init {
+        // Before API 33 RECEIVER_NOT_EXPORTED is ignored and a runtime receiver is exported, so there the
+        // sender must hold this app's signature permission (what androidx ContextCompat does); the
+        // per-share nonce stays as the second check. The PendingIntent is sent as this app.
+        if (Build.VERSION.SDK_INT >= 33) Api33.register(activity, receiver, IntentFilter(action))
+        else activity.registerReceiver(receiver, IntentFilter(action), activity.packageName + ".AKAN_NATIVE_INTERNAL_BROADCAST", null)
+        activity.registerActivityLifecycleCallbacks(lifecycle) // this activity only (API 29)
+    }
+
+    override fun destroy() {
+        runCatching { activity.unregisterReceiver(receiver) }
+        activity.unregisterActivityLifecycleCallbacks(lifecycle)
+    }
+
+    private class Problem(val code: String, message: String) : Exception(message)
+
+    private class Content(val title: String?, val body: String?, val files: List<Pair<File, String>>)
+
+    // Invalid options are "cannot share", as navigator.canShare answers.
+    override fun canShare(args: ShareOptions, reply: AkanNativeReply<ShareCanShareResult>) =
+        reply.resolve(ShareCanShareResult(value = reply.call.args.length() == 0 || runCatching { content(args) }.isSuccess))
+
+    private fun content(args: ShareOptions): Content {
+        val title = args.title?.ifEmpty { null }
+        val text = args.text?.ifEmpty { null }
+        val url = args.url?.ifEmpty { null }
+        if (url != null) {
+            val scheme = Uri.parse(url).scheme?.lowercase()
+            if (scheme == null || scheme in NOT_LINKS) throw Problem(AkanNativeErrorCode.INVALID_ARGS, "url must be an absolute URL (got $url)")
+        }
+        val files = (args.files ?: emptyList()).map { ref ->
+            localFile(ref) ?: throw Problem(AkanNativeErrorCode.NOT_FOUND, "$ref is not a file of this session")
+        }
+        val body = listOfNotNull(text, url).joinToString(" ").ifEmpty { null }
+        if (body == null && files.isEmpty()) throw Problem(AkanNativeErrorCode.INVALID_ARGS, "share needs text, url or files")
+        return Content(title, body, files)
+    }
+
+    /** The file and MIME type behind a /__akan_native/file/<id> URL. */
+    private fun localFile(ref: String): Pair<File, String>? = context.file(ref)
+
+    override fun share(args: ShareOptions, reply: AkanNativeReply<ShareResult>) {
+        if (pending != null) return reply.reject(AkanNativeErrorCode.CANCELLED, "a share sheet is already open")
+        val content = try {
+            content(args)
+        } catch (e: Problem) {
+            return reply.reject(e.code, e.message ?: "invalid share options")
+        }
+        if (content.files.isEmpty()) return launch(reply, content, emptyList())
+        // Copying can take a while for videos: off the main thread.
+        Thread {
+            try {
+                val uris = content.files.mapIndexed { i, (file, mime) -> stage(file, i) to mime }
+                context.runOnMain { launch(reply, content, uris) }
+            } catch (e: Exception) {
+                Log.e("AkanNative", "share: staging files failed", e)
+                reply.reject(AkanNativeErrorCode.INTERNAL, "could not prepare the files: $e")
+            }
+        }.start()
+    }
+
+    /** A content:// URI for [file]: its own if it is already in the provider's folder (camera photos), else a copy. */
+    private fun stage(file: File, index: Int): Uri {
+        if (NAME.matches(file.name)) {
+            val (inPlace, uri) = context.captureTarget(file.name)
+            if (inPlace.canonicalPath == file.canonicalPath) return uri
+        }
+        val safe = file.name.replace(Regex("[^A-Za-z0-9._-]"), "_").takeLast(100)
+        val (copy, uri) = context.captureTarget("share-${System.currentTimeMillis()}-$index-$safe")
+        file.copyTo(copy, overwrite = true)
+        return uri
+    }
+
+    private fun launch(reply: AkanNativeReply<ShareResult>, content: Content, files: List<Pair<Uri, String>>) {
+        if (pending != null) return reply.reject(AkanNativeErrorCode.CANCELLED, "a share sheet is already open")
+        val send = Intent(if (files.size > 1) Intent.ACTION_SEND_MULTIPLE else Intent.ACTION_SEND)
+        content.body?.let { send.putExtra(Intent.EXTRA_TEXT, it) }
+        content.title?.let { send.putExtra(Intent.EXTRA_SUBJECT, it).putExtra(Intent.EXTRA_TITLE, it) }
+        if (files.isEmpty()) {
+            send.type = "text/plain"
+        } else {
+            send.type = commonType(files.map { it.second })
+            val uris = ArrayList(files.map { it.first })
+            if (uris.size == 1) send.putExtra(Intent.EXTRA_STREAM, uris[0]) else send.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris)
+            val clip = ClipData.newRawUri(null, uris[0])
+            for (uri in uris.drop(1)) clip.addItem(ClipData.Item(uri))
+            send.clipData = clip
+            send.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+        }
+
+        val nonce = UUID.randomUUID().toString()
+        val chosen = Intent(action).setPackage(activity.packageName).putExtra(EXTRA_NONCE, nonce)
+        // Mutable so the chooser can add EXTRA_CHOSEN_COMPONENT; below API 31 every PendingIntent is.
+        val mutable = if (Build.VERSION.SDK_INT >= 31) PendingIntent.FLAG_MUTABLE else 0
+        val sender = PendingIntent.getBroadcast(activity, 0, chosen, PendingIntent.FLAG_UPDATE_CURRENT or mutable).intentSender
+        val chooser = Intent.createChooser(send, null, sender)
+        val p = Pending(reply, nonce)
+        pending = p
+        try {
+            context.startActivityForResult("share", chooser) { code, _ ->
+                pending = null
+                reply.resolve(ShareResult(completed = p.target != null || p.stopped || code == Activity.RESULT_OK, target = p.target))
+            }
+        } catch (e: ActivityNotFoundException) {
+            pending = null
+            reply.reject(AkanNativeErrorCode.UNSUPPORTED, "no share sheet on this device")
+        }
+    }
+
+    override fun onRestoredActivityResult(key: String, resultCode: Int, data: Intent?) {
+        // The process died while the sheet was open; the page that asked is gone (plugins.md C6).
+        Log.i("AkanNative", "share result after process restart dropped (result=$resultCode)")
+    }
+
+    private companion object {
+        const val EXTRA_NONCE = "com.akanjs.share.nonce"
+        val NOT_LINKS = setOf("javascript", "data", "blob", "file")
+        val NAME = Regex("[A-Za-z0-9_-][A-Za-z0-9._-]{0,127}")
+
+        // One type → that type; one major type → e.g. image/*; otherwise */*
+        // (Capacitor sends */* for every multi-file share).
+        fun commonType(types: List<String>): String {
+            val distinct = types.map { it.lowercase() }.distinct()
+            if (distinct.size == 1) return distinct[0]
+            val majors = distinct.map { it.substringBefore('/') }.distinct()
+            return if (majors.size == 1) "${majors[0]}/*" else "*/*"
+        }
+    }
+
+    private object Api33 {
+        fun register(activity: Activity, receiver: BroadcastReceiver, filter: IntentFilter) {
+            activity.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)
+        }
+    }
+}

package/vendor/@akanjs/native/plugins/share/ios/SharePlugin.swift

@@ -0,0 +1,142 @@
+import UIKit
+
+/// UIActivityViewController.
+/// - Presented from the topmost view controller; while a share sheet is already up (this plugin's or
+///   the WebView's own navigator.share) the call is CANCELLED
+///   (capacitor-plugins/share/ios/Sources/SharePlugin/SharePlugin.swift:67-78).
+/// - iPad shows the sheet as a popover, which needs an anchor: centered in the presenter, no arrow (:79-87).
+/// - The title becomes the subject (Mail) through UIActivityItemSource, the public API for it;
+///   Capacitor and react-native set the private "subject" key with KVC.
+/// - completionWithItemsHandler: (nil, false) means the sheet was closed. (type, false) means the user
+///   backed out of one activity, and the sheet usually stays up for another choice, so the call waits
+///   (react-native RCTActionSheetManager.mm:287-294); if the sheet did go away it resolves not completed.
+/// - files: /__akan_native/file/<id> URLs of this session, shared as the files themselves.
+/// Arguments arrive decoded and type-checked by the generated SharePluginSpec (PL-10).
+final class SharePlugin: SharePluginSpec {
+    static let id = "share"
+    private static let notLinks: Set<String> = ["javascript", "data", "blob", "file"]
+    private static let filePrefix = "/__akan_native/file/"
+    private let context: AkanNativePluginContext
+
+    /// canShare answers false for options it cannot decode instead of rejecting (src/index.ts, as
+    /// navigator.canShare does); everything else goes through the generated dispatch.
+    func handle(_ call: AkanNativeCall) {
+        if call.method == "canShare", (try? ShareOptions(akanNative: call.args, at: "")) == nil {
+            return call.resolve(["value": false])
+        }
+        akanNativeDispatch(call)
+    }
+
+    init(context: AkanNativePluginContext) {
+        self.context = context
+    }
+
+    func canShare(_ args: ShareOptions, _ reply: AkanNativeReply<ShareCanShareResult>) {
+        // Invalid options are "cannot share", as navigator.canShare answers.
+        reply.resolve(ShareCanShareResult(value: reply.call.args.isEmpty || (try? content(args)) != nil))
+    }
+
+    private struct Content {
+        var subject: String?
+        var items: [Any]
+    }
+
+    private struct Problem: Error {
+        let code: AkanNativeErrorCode
+        let message: String
+    }
+
+    private func content(_ args: ShareOptions) throws(Problem) -> Content {
+        func text(_ value: String?) -> String? {
+            value?.isEmpty == false ? value : nil
+        }
+        let subject = text(args.title)
+        var items: [Any] = []
+        if let body = text(args.text) { items.append(body) }
+        if let link = text(args.url) {
+            guard let url = URL(string: link), let scheme = url.scheme?.lowercased(), !Self.notLinks.contains(scheme) else {
+                throw Problem(code: .invalidArgs, message: "url must be an absolute URL (got \(link))")
+            }
+            items.append(url)
+        }
+        for ref in args.files ?? [] {
+            guard let id = Self.fileId(ref) else {
+                throw Problem(code: .invalidArgs, message: "files must be /__akan_native/file/ URLs")
+            }
+            guard let local = localFile(id) else { throw Problem(code: .notFound, message: "\(ref) is not a file of this session") }
+            items.append(local)
+        }
+        guard !items.isEmpty else { throw Problem(code: .invalidArgs, message: "share needs text, url or files") }
+        return Content(subject: subject, items: items)
+    }
+
+    /// "/__akan_native/file/<id>" or its absolute form "app://localhost/__akan_native/file/<id>".
+    private static func fileId(_ ref: String) -> String? {
+        var path = ref
+        if !ref.hasPrefix("/") {
+            guard let url = URL(string: ref), url.scheme == "app", url.host == "localhost" else { return nil }
+            path = url.path
+        }
+        guard path.hasPrefix(filePrefix) else { return nil }
+        let id = String(path.dropFirst(filePrefix.count))
+        return id.isEmpty || id.contains("/") ? nil : id
+    }
+
+    /// The file behind a FileRef id. AkanNativePluginContext has no lookup for this yet, so this reads the
+    /// shell's registry (same module); switch to the context once it offers one.
+    private func localFile(_ id: String) -> URL? {
+        context.file("/__akan_native/file/\(id)")?.url
+    }
+
+    func share(_ args: ShareOptions, _ reply: AkanNativeReply<ShareResult>) {
+        let content: Content
+        do {
+            content = try self.content(args)
+        } catch {
+            return reply.reject(error.code, error.message)
+        }
+        guard var presenter = context.viewController else { return reply.reject(.internalError, "no view controller to present from") }
+        while let next = presenter.presentedViewController {
+            if next is UIActivityViewController { return reply.reject(.cancelled, "a share sheet is already open") }
+            presenter = next
+        }
+        let view = presenter.view!
+
+        var items = content.items
+        if let subject = content.subject, let first = items.first { items[0] = SubjectItem(first, subject: subject) }
+        let sheet = UIActivityViewController(activityItems: items, applicationActivities: nil)
+        sheet.completionWithItemsHandler = { [weak sheet] type, completed, _, error in
+            if let error { return reply.reject(.internalError, "sharing failed: \(error.localizedDescription)") }
+            if completed { return reply.resolve(ShareResult(completed: true, target: type?.rawValue)) }
+            if type == nil { return reply.resolve(ShareResult(completed: false)) }
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak sheet] in
+                MainActor.assumeIsolated {
+                    if sheet?.presentingViewController == nil { reply.resolve(ShareResult(completed: false)) }
+                }
+            }
+        }
+        if let popover = sheet.popoverPresentationController {
+            popover.sourceView = view
+            popover.sourceRect = CGRect(x: view.bounds.midX, y: view.bounds.midY, width: 0, height: 0)
+            popover.permittedArrowDirections = []
+        }
+        context.present(sheet) { reply.reject(.internalError, "nothing to present the share sheet from") }
+    }
+}
+
+/// Wraps the first item to give activities a subject line.
+private final class SubjectItem: NSObject, UIActivityItemSource {
+    private let item: Any
+    private let subject: String
+
+    init(_ item: Any, subject: String) {
+        self.item = item
+        self.subject = subject
+    }
+
+    func activityViewControllerPlaceholderItem(_ controller: UIActivityViewController) -> Any { item }
+
+    func activityViewController(_ controller: UIActivityViewController, itemForActivityType type: UIActivity.ActivityType?) -> Any? { item }
+
+    func activityViewController(_ controller: UIActivityViewController, subjectForActivityType type: UIActivity.ActivityType?) -> String { subject }
+}

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

@@ -0,0 +1,18 @@
+{
+  "id": "share",
+  "apiVersion": 1,
+  "methods": ["share", "canShare"],
+  "events": [],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": "web",
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "SharePlugin"
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.share.SharePlugin",
+    "manifestXml": "<permission android:name=\"${applicationId}.AKAN_NATIVE_INTERNAL_BROADCAST\" android:protectionLevel=\"signature\" />\n    <uses-permission android:name=\"${applicationId}.AKAN_NATIVE_INTERNAL_BROADCAST\" />"
+  }
+}

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

@@ -0,0 +1,87 @@
+
+
+import * as React from "react";
+import { AkanNativeError, definePlugin } from "../../../packages/core/src/index.ts";
+import { web, webShareAvailable } from "./web.ts";
+
+export interface ShareOptions {
+  /** Subject line for mail-like targets, preview title on Android. */
+  title?: string;
+  text?: string;
+  /** An absolute URL. On Android it is appended to the text (the intent has one text field). */
+  url?: string;
+  /**
+   * Files as FileRef URLs (`/__akan_native/file/<id>`) returned by other plugins, e.g. camera.takePhoto().
+   * On the web also blob: and same-origin URLs. Not yet on Android (see canShare).
+   */
+  files?: string[];
+}
+
+export interface ShareResult {
+  /** False when the user closed the share sheet without choosing a target. */
+  completed: boolean;
+  /**
+   * What received the share, when the platform tells: the package name on Android, the activity type
+   * on iOS (com.apple.UIKit.activity.Mail, …). Missing on the web and when unknown.
+   */
+  target?: string;
+}
+
+/**
+ * The system share sheet: UIActivityViewController (iOS), the Android chooser, navigator.share
+ * (web, and the desktop WebView: WKWebView on macOS, WebView2 on Windows). Linux has no share
+ * sheet (WebKitGTK has no navigator.share): canShare() answers false and share() rejects
+ * UNSUPPORTED. Closing the sheet resolves `{ completed: false }` rather than rejecting, as
+ * react-native Share does ("dismissedAction").
+ */
+export interface ShareApi {
+  /**
+   * Opens the share sheet. Needs a user gesture on the web (call it from a click, before any await).
+   * Rejects INVALID_ARGS without text, url or files, CANCELLED while another share sheet is open,
+   * UNSUPPORTED where sharing (or sharing these files) is not available.
+   */
+  share(options: ShareOptions): Promise<ShareResult>;
+  /**
+   * Whether share() would work for these options; without options (or with {}) whether a share sheet
+   * exists at all. Invalid options answer false instead of rejecting, as navigator.canShare does.
+   */
+  canShare(options?: ShareOptions): Promise<{ value: boolean }>;
+}
+
+export const share = definePlugin<ShareApi>("share", {
+  methods: ["share", "canShare"],
+  web,
+});
+
+export interface UseShare {
+  /** False where no share sheet exists (desktop Firefox, insecure origins): hide the share button. */
+  supported: boolean;
+  pending: boolean;
+  /** Last failure. Closing the sheet is not a failure. */
+  error: AkanNativeError | null;
+  /** Resolves null on failure (see `error`). */
+  share(options: ShareOptions): Promise<ShareResult | null>;
+}
+
+export function useShare(): UseShare {
+  const [pending, setPending] = React.useState(false);
+  const [error, setError] = React.useState<AkanNativeError | null>(null);
+
+  const run = React.useCallback(async (options: ShareOptions) => {
+    setPending(true);
+    setError(null);
+    try {
+      
+      return await share.share(options);
+    } catch (e) {
+      const err = AkanNativeError.from(e);
+      if (err.code !== "CANCELLED") setError(err);
+      return null;
+    } finally {
+      setPending(false);
+    }
+  }, []);
+
+  const where = share.implementation("share");
+  return { supported: where === "native" || (where === "web" && webShareAvailable()), pending, error, share: run };
+}

package/vendor/@akanjs/native/plugins/share/src/options.ts

@@ -0,0 +1,43 @@
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import type { ShareOptions } from "./index.ts";
+
+const NOT_LINKS = ["javascript:", "data:", "blob:", "file:"];
+
+const invalid = (message: string) => new AkanNativeError("INVALID_ARGS", message);
+
+/**
+ * Normalizes share() options the way the native implementations read them: empty strings and
+ * null count as missing, at least one of text, url or files is required, url is absolute.
+ */
+export function checkOptions(options: unknown): ShareOptions {
+  if (!options || typeof options !== "object" || Array.isArray(options))
+    throw invalid("share options must be an object");
+  const { title, text, url, files } = options as Record<string, unknown>;
+  const out: ShareOptions = {};
+  for (const [key, value] of [
+    ["title", title],
+    ["text", text],
+    ["url", url],
+  ] as const) {
+    if (value === undefined || value === null || value === "") continue;
+    if (typeof value !== "string") throw invalid(`${key} must be a string`);
+    out[key] = value;
+  }
+  if (files !== undefined && files !== null) {
+    if (!Array.isArray(files) || files.some((f) => typeof f !== "string" || f.length === 0))
+      throw invalid("files must be an array of file URLs");
+    if (files.length > 0) out.files = files as string[];
+  }
+  if (!out.text && !out.url && !out.files) throw invalid("share needs text, url or files");
+  if (out.url) {
+    let parsed: URL;
+    try {
+      parsed = new URL(out.url);
+    } catch {
+      throw invalid(`url must be an absolute URL (got ${out.url})`);
+    }
+    if (NOT_LINKS.includes(parsed.protocol))
+      throw invalid(`${parsed.protocol} URLs cannot be shared as links; use files`);
+  }
+  return out;
+}

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

@@ -0,0 +1,116 @@
+import { AkanNativeError, defineWebPlugin } from "../../../packages/core/src/index.ts";
+import type { ShareApi, ShareOptions, ShareResult } from "./index.ts";
+import { checkOptions } from "./options.ts";
+
+export function webShareAvailable(): boolean {
+  return typeof navigator !== "undefined" && typeof navigator.share === "function";
+}
+
+const EXTENSIONS: Record<string, string> = {
+  "image/jpeg": "jpg",
+  "image/png": "png",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/heic": "heic",
+  "application/pdf": "pdf",
+  "text/plain": "txt",
+  "video/mp4": "mp4",
+  "video/quicktime": "mov",
+  "audio/mpeg": "mp3",
+};
+
+/** A file name for the share target: the URL's last path segment if it has an extension. */
+export function fileName(url: string, mime: string, index: number, base?: string): string {
+  if (!url.startsWith("blob:") && !url.startsWith("data:")) {
+    try {
+      const last = new URL(url, base ?? globalThis.location?.href).pathname.split("/").pop();
+      if (last && /\.[A-Za-z0-9]{1,8}$/.test(last)) return decodeURIComponent(last);
+    } catch {
+    }
+  }
+  const type = mime.split(";")[0]!.trim().toLowerCase();
+  const ext = EXTENSIONS[type] ?? (type.split("/")[1]?.replace(/[^a-z0-9]/g, "") || "bin");
+  return `file${index + 1}.${ext}`;
+}
+
+async function loadFiles(urls: string[]): Promise<File[]> {
+  return Promise.all(
+    urls.map(async (url, i) => {
+      let response: Response;
+      try {
+        response = await fetch(url);
+      } catch (error) {
+        throw new AkanNativeError("NOT_FOUND", `could not read ${url}`, { cause: error });
+      }
+      if (!response.ok) throw new AkanNativeError("NOT_FOUND", `could not read ${url} (${response.status})`);
+      const blob = await response.blob();
+      return new File([blob], fileName(url, blob.type, i), { type: blob.type });
+    }),
+  );
+}
+
+function toData(options: ShareOptions): ShareData {
+  const data: ShareData = {};
+  if (options.title) data.title = options.title;
+  if (options.text) data.text = options.text;
+  if (options.url) data.url = options.url;
+  return data;
+}
+
+function run(data: ShareData): Promise<ShareResult> {
+  return navigator.share(data).then(
+    () => ({ completed: true }),
+    (error: unknown) => {
+      const name = (error as { name?: string })?.name;
+      if (name === "AbortError") return { completed: false }; 
+      if (name === "InvalidStateError") throw new AkanNativeError("CANCELLED", "a share sheet is already open");
+      if (name === "TypeError" || name === "DataError")
+        throw new AkanNativeError("INVALID_ARGS", String((error as Error).message));
+      throw AkanNativeError.from(error); 
+    },
+  );
+}
+
+export const web = defineWebPlugin<ShareApi>({
+  methods: {
+    share(options) {
+      const checked = checkOptions(options);
+      if (!webShareAvailable()) {
+        throw new AkanNativeError(
+          "UNSUPPORTED",
+          "the Web Share API is not available here (desktop Firefox, insecure context)",
+        );
+      }
+      const data = toData(checked);
+      if (!checked.files) return run(data);
+      return loadFiles(checked.files).then((files) => {
+        const withFiles: ShareData = { ...data, files };
+        if (typeof navigator.canShare === "function" && !navigator.canShare(withFiles)) {
+          throw new AkanNativeError("UNSUPPORTED", "this browser cannot share these files");
+        }
+        return run(withFiles);
+      });
+    },
+    async canShare(options) {
+      if (!webShareAvailable()) return { value: false };
+      
+      if (!options || Object.keys(options).length === 0) return { value: true };
+      let checked: ShareOptions;
+      try {
+        checked = checkOptions(options);
+      } catch {
+        return { value: false }; 
+      }
+      const data = toData(checked);
+      if (typeof navigator.canShare !== "function") return { value: !checked.files };
+      if (checked.files) {
+        try {
+          data.files = await loadFiles(checked.files);
+        } catch {
+          return { value: false };
+        }
+      }
+      return { value: navigator.canShare(data) };
+    },
+  },
+});

package/vendor/@akanjs/native/plugins/single-instance/native-plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "single-instance",
+  "apiVersion": 1,
+  "methods": [],
+  "events": ["secondInstance"],
+  "web": null,
+  "desktop": "./src/desktop.ts",
+  "ios": null,
+  "android": null
+}