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

package/vendor/@akanjs/native/plugins/local-notifications/src/web.ts

@@ -0,0 +1,158 @@
+import { AkanNativeError, defineWebPlugin } from "../../../packages/core/src/index.ts";
+import type {
+  DeliveredNotification,
+  LocalNotificationsApi,
+  LocalNotificationsEvents,
+  NotificationEvent,
+  PermissionState,
+} from "./index.ts";
+import { checkIds, checkScheduled, type ScheduledNotification } from "./schedule.ts";
+import { NotificationTimers, systemTimers } from "./timers.ts";
+
+type Emit<T> = (data: T) => void;
+
+let emitReceived: Emit<NotificationEvent> | null = null;
+let emitAction: Emit<NotificationEvent> | null = null;
+/** Taps before anything listened (plugins.md C2). */
+const pendingActions: NotificationEvent[] = [];
+/** Notifications this page showed and that are still open. */
+const shown = new Map<number, { notification: Notification; info: DeliveredNotification }>();
+
+function api(): typeof Notification | null {
+  return typeof Notification === "function" ? Notification : null;
+}
+
+function state(): PermissionState {
+  const N = api();
+  if (!N) throw new AkanNativeError("UNSUPPORTED", "this browser has no Notification API");
+  return N.permission === "granted" ? "granted" : N.permission === "denied" ? "denied" : "prompt";
+}
+
+function eventOf(n: ScheduledNotification): NotificationEvent {
+  const event: NotificationEvent = { id: n.id, title: n.title, body: n.body };
+  if (n.data) event.data = n.data;
+  return event;
+}
+
+/** close() does not always fire "close" (headless Chrome, checked), so forget it here too. */
+function dismiss(id: number): void {
+  const entry = shown.get(id);
+  if (!entry) return;
+  shown.delete(id);
+  entry.notification.close();
+}
+
+function show(n: ScheduledNotification): void {
+  const N = api();
+  if (!N || N.permission !== "granted") return; 
+  dismiss(n.id);
+  
+  const notification = new N(n.title, { body: n.body, tag: `akan-native-${n.id}` });
+  const info: DeliveredNotification = { id: n.id, title: n.title, body: n.body, at: Date.now() };
+  if (n.data) info.data = n.data;
+  shown.set(n.id, { notification, info });
+  notification.onclose = () => {
+    if (shown.get(n.id)?.notification === notification) shown.delete(n.id);
+  };
+  notification.onclick = () => {
+    try {
+      window.focus();
+    } catch {}
+    dismiss(n.id);
+    const event = eventOf(n);
+    if (emitAction) emitAction(event);
+    else pendingActions.push(event);
+  };
+  emitReceived?.(eventOf(n));
+}
+
+/** Set while schedule() shows due notifications itself, so their errors reach the caller. */
+let throwing = false;
+
+const timers = new NotificationTimers({
+  ...systemTimers,
+  show(n) {
+    try {
+      show(n);
+    } catch (error) {
+      if (throwing)
+        throw error instanceof TypeError
+          ? new AkanNativeError("UNSUPPORTED", "this browser only shows notifications from a service worker")
+          : error;
+      console.warn("[akan-native] local-notifications: showing a notification failed", error);
+    }
+  },
+});
+
+export const web = defineWebPlugin<LocalNotificationsApi, LocalNotificationsEvents>({
+  methods: {
+    async schedule(args) {
+      const list = checkScheduled(args); 
+      const N = api();
+      if (!N) throw new AkanNativeError("UNSUPPORTED", "this browser has no Notification API");
+      if (N.permission !== "granted")
+        throw new AkanNativeError(
+          "PERMISSION_DENIED",
+          "notification permission is not granted (call requestPermission)",
+        );
+      throwing = true;
+      try {
+        return { ids: timers.schedule(list) };
+      } finally {
+        throwing = false;
+      }
+    },
+    async cancel(args) {
+      timers.cancel(checkIds(args, "cancel"));
+    },
+    getPending: async () => ({ notifications: api() ? timers.list() : [] }),
+    getDelivered: async () => ({ notifications: [...shown.values()].map(({ info }) => ({ ...info })) }),
+    async removeDelivered(args) {
+      for (const id of checkIds(args, "removeDelivered")) dismiss(id);
+    },
+    async removeAllDelivered() {
+      for (const id of [...shown.keys()]) dismiss(id);
+    },
+    async createChannel() {},
+    checkPermission: async () => ({ display: state() }),
+    requestPermission() {
+      
+      const N = api();
+      if (!N) return Promise.reject(new AkanNativeError("UNSUPPORTED", "this browser has no Notification API"));
+      if (N.permission !== "default") return Promise.resolve({ display: state() });
+      return new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+          if (done) return;
+          done = true;
+          resolve({ display: state() });
+        };
+        
+        const result = N.requestPermission(finish);
+        if (result && typeof result.then === "function") result.then(finish, finish);
+      });
+    },
+  },
+  events: {
+    received(emit) {
+      emitReceived = emit;
+      return () => {
+        emitReceived = null;
+      };
+    },
+    action(emit) {
+      emitAction = emit;
+      for (const event of pendingActions.splice(0)) emit(event);
+      return () => {
+        emitAction = null;
+      };
+    },
+  },
+});
+
+/** For tests: forget everything this module keeps. */
+export function resetWebState(): void {
+  for (const id of [...shown.keys()]) dismiss(id);
+  pendingActions.length = 0;
+  timers.cancel(timers.list().map((n) => n.id));
+}

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

@@ -0,0 +1,10 @@
+{
+  "id": "menu",
+  "apiVersion": 1,
+  "methods": ["setAppMenu", "resetAppMenu", "getAppMenu", "popupContextMenu", "triggerItem"],
+  "events": ["click"],
+  "web": null,
+  "desktop": "./src/desktop.ts",
+  "ios": null,
+  "android": null
+}

package/vendor/@akanjs/native/plugins/menu/src/desktop.ts

@@ -0,0 +1,52 @@
+
+
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import { defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import type { MenuApi, MenuClick, MenuEvents, MenuItem } from "./index.ts";
+
+function items(value: unknown): MenuItem[] {
+  if (!Array.isArray(value)) throw new AkanNativeError("INVALID_ARGS", "items must be an array of menu items");
+  return value as MenuItem[];
+}
+
+function coordinate(value: unknown, name: string): number | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new AkanNativeError("INVALID_ARGS", `${name} must be a number`);
+  return value;
+}
+
+export default defineDesktopPlugin<MenuApi, MenuEvents>({
+  id: "menu",
+  methods: {
+    setAppMenu: async (args, ctx) => {
+      await ctx.shell("menu.setApp", { items: items(args?.items) });
+    },
+    resetAppMenu: async (_args, ctx) => {
+      await ctx.shell("menu.reset");
+    },
+    getAppMenu: async (_args, ctx) => ({ items: (await ctx.shell("menu.get")) as MenuItem[] }),
+    popupContextMenu: async (args, ctx) => {
+      const x = coordinate(args?.x, "x");
+      const y = coordinate(args?.y, "y");
+      if ((x === undefined) !== (y === undefined))
+        throw new AkanNativeError("INVALID_ARGS", "give both x and y, or neither for the mouse position");
+      const closeAfterMs = coordinate(args?.closeAfterMs, "closeAfterMs");
+      
+      await ctx.shell("menu.popup", { items: items(args?.items), x, y, closeAfterMs, window: ctx.window });
+    },
+    triggerItem: async (args, ctx) => {
+      if (typeof args?.id !== "string") throw new AkanNativeError("INVALID_ARGS", "id must be a string");
+      await ctx.shell("menu.trigger", { id: args.id });
+    },
+  },
+  events: {
+    click: (emit, ctx) =>
+      ctx.onNativeEvent("menu", (e) => {
+        const click: MenuClick = { id: e.id as string, source: e.source === "context" ? "context" : "app" };
+        if (typeof e.checked === "boolean") click.checked = e.checked;
+        
+        emit(click, click.source === "context" && typeof e.window === "number" ? { window: e.window } : "focused");
+      }),
+  },
+});

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

@@ -0,0 +1,107 @@
+import { definePlugin } from "../../../packages/core/src/index.ts";
+
+/**
+ * Desktop menus: the app menu bar and context menus (plugins.md §5).
+ *
+ * - macOS: the menu bar holds only submenus, and the first one is the app menu (macOS titles it
+ *   with the app's name). Until setAppMenu is called the app has the default menu: App, Edit and
+ *   Window (D1). Keep an Edit menu (role "editMenu" or its items): without it Cmd+C/V/X/A do
+ *   nothing in the page.
+ * - Windows and Linux: a menu bar in every window, from the same item tree (the bar holds only
+ *   submenus there too, so one tree fits every OS). No menu bar until setAppMenu, and
+ *   getAppMenu() is [] then: the webview handles Ctrl+C/V itself. CmdOrCtrl is Ctrl; Cmd is the
+ *   Windows (Super) key, which Windows menus show but cannot fire.
+ *   Roles: appMenu is a "File" menu with About and Exit (Windows) or Quit (Linux); editMenu,
+ *   windowMenu (Minimize, Maximize, Full Screen, Close) and helpMenu (only with items) are the
+ *   usual menus. about shows a small About box, quit asks the app to quit as Cmd+Q does, the
+ *   window roles act on the menu's window. The editing roles run the page's command; their keys
+ *   stay with the page (shown next to the item, not taken from text fields). hide, hideOthers,
+ *   showAll, bringAllToFront and services are macOS only and left out.
+ *   Context menus open at the page position or the mouse; on Linux (GTK) a Wayland session may
+ *   refuse a menu opened without a recent click.
+ * - Web, iOS and Android: UNSUPPORTED.
+ *
+ * Clicks arrive as `click` events: app menu clicks at the most recently focused window that
+ * listens, context menu clicks at the window that opened the menu.
+ */
+
+/** Standard items. Their action goes to the focused page or window and macOS enables them itself. */
+export type MenuItemRole =
+  | "about"
+  | "hide"
+  | "hideOthers"
+  | "showAll"
+  | "quit"
+  | "undo"
+  | "redo"
+  | "cut"
+  | "copy"
+  | "paste"
+  | "pasteAndMatchStyle"
+  | "delete"
+  | "selectAll"
+  | "minimize"
+  | "zoom"
+  | "close"
+  | "toggleFullScreen"
+  | "bringAllToFront";
+
+/**
+ * Standard submenus. appMenu, editMenu and windowMenu bring their usual items unless `submenu`
+ * lists others; windowMenu also gets the window list, helpMenu the help search field and
+ * services the Services items from macOS.
+ */
+export type SubmenuRole = "appMenu" | "editMenu" | "windowMenu" | "helpMenu" | "services";
+
+export interface MenuItem {
+  /** Reported by `click`. Required for items you handle (not for roles, separators or submenus). */
+  id?: string;
+  label?: string;
+  /** e.g. "CmdOrCtrl+Shift+K" (CmdOrCtrl is Command on macOS). */
+  accelerator?: string;
+  /** Default true. */
+  enabled?: boolean;
+  /** Makes a check item; it toggles itself when chosen and `click` reports the new state. */
+  checked?: boolean;
+  submenu?: MenuItem[];
+  role?: MenuItemRole | SubmenuRole;
+  type?: "separator";
+}
+
+export interface MenuClick {
+  id: string;
+  source: "app" | "context";
+  /** Check items: the state after the click. */
+  checked?: boolean;
+}
+
+export interface MenuApi {
+  /** Replaces the app menu. */
+  setAppMenu(args: { items: MenuItem[] }): Promise<void>;
+  /** Back to the default menu (App, Edit, Window). */
+  resetAppMenu(): Promise<void>;
+  /** The current app menu in setAppMenu's shape (roles come back as roles). */
+  getAppMenu(): Promise<{ items: MenuItem[] }>;
+  /**
+   * Opens a context menu in the calling window at a page position (CSS px), or at the mouse.
+   * Resolves when the menu closes; a chosen item has sent its `click` by then.
+   * `closeAfterMs` closes it unchosen, for automated tests.
+   */
+  popupContextMenu(args: { items: MenuItem[]; x?: number; y?: number; closeAfterMs?: number }): Promise<void>;
+  /** Acts as if the user chose an app menu item (automated tests, where nobody can click). */
+  triggerItem(args: { id: string }): Promise<void>;
+}
+
+export interface MenuEvents {
+  click: MenuClick;
+}
+
+export const menu = definePlugin<MenuApi, MenuEvents>("menu", {
+  methods: ["setAppMenu", "resetAppMenu", "getAppMenu", "popupContextMenu", "triggerItem"],
+  events: ["click"],
+});
+
+/** Menu clicks (app menu and context menus). Returns an unsubscribe function. */
+export function onMenuClick(handler: (click: MenuClick) => void): () => void {
+  return menu.listen("click", handler);
+}

package/vendor/@akanjs/native/plugins/network/android/NetworkPlugin.kt

@@ -0,0 +1,124 @@
+package com.akanjs.plugins.network
+
+import android.app.Activity
+import android.app.Application
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+
+/**
+ * The default network, with ACCESS_NETWORK_STATE (normal permission).
+ * - connected needs NET_CAPABILITY_INTERNET and NET_CAPABILITY_VALIDATED, not just a network
+ *   (capacitor-plugins/network/android/.../Network.java:74-93). Validation lands a moment after a
+ *   network appears, as another onCapabilitiesChanged.
+ * - Events use the capabilities the callback is given. Capacitor queries getNetworkCapabilities()
+ *   inside the callback (Network.java:28-32 → NetworkPlugin.java:84-86), which the
+ *   ConnectivityManager docs warn may return stale values there.
+ * - The callback runs on the main looper and only while the page listens. Capacitor unregisters it
+ *   on pause and compares the status on resume (NetworkPlugin.java:57-82); here it stays registered
+ *   and resume only re-reads the status, in case a frozen background process missed a callback.
+ * - A handover (Wi-Fi off → cellular) loses the old default network about 100 ms before the new one
+ *   arrives (measured on the emulator). Capacitor reports that gap as offline (NetworkPlugin.java:24-29);
+ *   here "none" is sent only when no network follows within LOST_GRACE_MS.
+ * The result and event types come from the generated NetworkPluginSpec (PL-10).
+ */
+class NetworkPlugin(private val context: AkanNativePluginContext) : NetworkPluginSpec {
+    private val none = NetworkStatus(connected = false, type = NetworkConnectionType.NONE)
+    private val connectivity: ConnectivityManager? = context.activity.getSystemService(ConnectivityManager::class.java)
+    private val events = NetworkEvents(context)
+    private var callback: ConnectivityManager.NetworkCallback? = null
+    private var defaultNetwork: Network? = null
+    private var last: NetworkStatus? = null
+    private val main = Handler(Looper.getMainLooper())
+    private val offline = Runnable { update(none) }
+
+    private val lifecycle = object : Application.ActivityLifecycleCallbacks {
+        override fun onActivityResumed(activity: Activity) = update(current())
+        override fun onActivityPaused(activity: Activity) {}
+        override fun onActivityStarted(activity: Activity) {}
+        override fun onActivityStopped(activity: Activity) {}
+        override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+        override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+        override fun onActivityDestroyed(activity: Activity) {}
+    }
+
+    override fun getStatus(reply: AkanNativeReply<NetworkStatus>) = reply.resolve(current())
+
+    override fun startListening(event: String) {
+        val cm = connectivity
+        if (event != "change" || callback != null || cm == null) return
+        last = current()
+        val cb = object : ConnectivityManager.NetworkCallback() {
+            override fun onCapabilitiesChanged(network: Network, capabilities: NetworkCapabilities) {
+                main.removeCallbacks(offline)
+                defaultNetwork = network
+                update(status(capabilities))
+            }
+
+            override fun onLost(network: Network) {
+                // A switch reports the new default network; only losing the current one means offline.
+                if (network != defaultNetwork) return
+                defaultNetwork = null
+                main.postDelayed(offline, LOST_GRACE_MS)
+            }
+        }
+        try {
+            // Delivers the current default network right away; that matches `last` and sends nothing.
+            cm.registerDefaultNetworkCallback(cb, main)
+        } catch (e: RuntimeException) { // SecurityException without the permission, TooManyRequestsException
+            Log.w("AkanNative", "network: cannot watch the default network", e)
+            return
+        }
+        callback = cb
+        context.activity.registerActivityLifecycleCallbacks(lifecycle)
+    }
+
+    override fun stopListening(event: String) {
+        val cb = callback
+        if (event != "change" || cb == null) return
+        connectivity?.unregisterNetworkCallback(cb)
+        context.activity.unregisterActivityLifecycleCallbacks(lifecycle)
+        main.removeCallbacks(offline)
+        callback = null
+        defaultNetwork = null
+    }
+
+    override fun destroy() = stopListening("change")
+
+    private fun update(next: NetworkStatus) {
+        if (callback == null || next == last) return
+        last = next
+        events.change(next)
+    }
+
+    /** Queried outside network callbacks, where the answer is current. */
+    private fun current(): NetworkStatus {
+        val cm = connectivity ?: return none
+        val network = cm.activeNetwork ?: return none
+        val capabilities = cm.getNetworkCapabilities(network) ?: return none
+        return status(capabilities)
+    }
+
+    private fun status(capabilities: NetworkCapabilities): NetworkStatus {
+        val connected = capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
+            capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+        // A VPN's capabilities carry the transports of the networks under it.
+        val type = when {
+            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> NetworkConnectionType.WIFI
+            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> NetworkConnectionType.CELLULAR
+            capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> NetworkConnectionType.ETHERNET
+            else -> NetworkConnectionType.UNKNOWN
+        }
+        return NetworkStatus(connected = connected, type = type)
+    }
+
+    private companion object {
+        const val LOST_GRACE_MS = 1000L
+    }
+}

package/vendor/@akanjs/native/plugins/network/ios/NetworkPlugin.swift

@@ -0,0 +1,82 @@
+import Network
+
+/// NWPathMonitor (capacitor-plugins/network/ios still bundles a SCNetworkReachability copy, Reachability.swift).
+/// The monitor runs only while needed: from the first $listen to the last $unlisten, or for a getStatus()
+/// until the first path arrives. A new monitor delivers its first path asynchronously (currentPath is
+/// not ready right after start), so getStatus waits for it instead of reading currentPath.
+/// connected = .satisfied. Unlike Android, iOS does not validate internet access, so a captive portal
+/// Wi-Fi counts as connected. In the simulator the path is the Mac's.
+/// The result and event types come from the generated NetworkPluginSpec (PL-10).
+final class NetworkPlugin: NetworkPluginSpec {
+    static let id = "network"
+
+    private let context: AkanNativePluginContext
+    private var monitor: NWPathMonitor?
+    private var status: NetworkStatus?
+    private var waiting: [AkanNativeReply<NetworkStatus>] = []
+    private var listening = false
+
+    init(context: AkanNativePluginContext) {
+        self.context = context
+    }
+
+    func getStatus(_ reply: AkanNativeReply<NetworkStatus>) {
+        if let status { return reply.resolve(status) }
+        waiting.append(reply)
+        startMonitor()
+    }
+
+    func startListening(_ event: String) {
+        guard event == "change" else { return }
+        listening = true
+        startMonitor()
+    }
+
+    func stopListening(_ event: String) {
+        guard event == "change" else { return }
+        listening = false
+        stopIfIdle()
+    }
+
+    private func startMonitor() {
+        guard monitor == nil else { return }
+        let monitor = NWPathMonitor()
+        monitor.pathUpdateHandler = { [weak self] path in
+            let next = NetworkPlugin.status(of: path)
+            MainActor.assumeIsolated { self?.update(next) } // started on the main queue
+        }
+        monitor.start(queue: .main)
+        self.monitor = monitor
+    }
+
+    private func update(_ next: NetworkStatus) {
+        let previous = status
+        status = next
+        let replies = waiting
+        waiting.removeAll()
+        for reply in replies { reply.resolve(next) }
+        // The first path of a monitor is the starting point, not a change.
+        if listening, let previous, previous.connected != next.connected || previous.type != next.type {
+            NetworkEvents(context).change(next)
+        }
+        stopIfIdle()
+    }
+
+    private func stopIfIdle() {
+        guard !listening, waiting.isEmpty, let monitor else { return }
+        monitor.cancel()
+        self.monitor = nil
+        status = nil // stale once nothing watches
+    }
+
+    nonisolated private static func status(of path: NWPath) -> NetworkStatus {
+        let connected = path.status == .satisfied
+        let type: NetworkConnectionType =
+            if path.usesInterfaceType(.wifi) { .wifi }
+            else if path.usesInterfaceType(.cellular) { .cellular }
+            else if path.usesInterfaceType(.wiredEthernet) { .ethernet }
+            else if connected { .unknown } // loopback or a tunnel (.other)
+            else { .none_ }
+        return NetworkStatus(connected: connected, type: type)
+    }
+}

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

@@ -0,0 +1,19 @@
+{
+  "id": "network",
+  "apiVersion": 1,
+  "methods": ["getStatus"],
+  "events": ["change"],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": "web",
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "NetworkPlugin",
+    "frameworks": ["Network"]
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.network.NetworkPlugin",
+    "permissions": ["android.permission.ACCESS_NETWORK_STATE"]
+  }
+}

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

@@ -0,0 +1,59 @@
+import { createLiveValue, definePlugin, shallowEqual } from "../../../packages/core/src/index.ts";
+import { useLiveValue } from "../../../packages/react/src/index.ts";
+import { web } from "./web.ts";
+
+/** The medium of the active network. "unknown" for others (VPN only, Bluetooth, USB) or where the host cannot tell. */
+export type ConnectionType = "wifi" | "cellular" | "ethernet" | "none" | "unknown";
+
+export interface NetworkStatus {
+  /**
+   * Whether the active network can reach the internet, as far as the OS knows. Android requires a
+   * validated connection, so a captive portal Wi-Fi is not connected there. iOS and browsers only
+   * know that a route exists.
+   */
+  connected: boolean;
+  /** "none" only when there is no network at all; a Wi-Fi without internet is { connected: false, type: "wifi" }. */
+  type: ConnectionType;
+}
+
+export interface NetworkApi {
+  getStatus(): Promise<NetworkStatus>;
+}
+
+export interface NetworkEvents {
+  /** Sent when `connected` or `type` changes. */
+  change: NetworkStatus;
+}
+
+export const network = definePlugin<NetworkApi, NetworkEvents>("network", {
+  methods: ["getStatus"],
+  events: ["change"],
+  web,
+});
+
+function guess(): NetworkStatus {
+  const online = typeof navigator === "undefined" || navigator.onLine !== false;
+  return { connected: online, type: online ? "unknown" : "none" };
+}
+
+const current = createLiveValue<NetworkStatus>(
+  guess(),
+  (set) => {
+    let live = true;
+    const stop = network.listen("change", set);
+    network
+      .getStatus()
+      .then((status) => live && set(status))
+      .catch(() => {});
+    return () => {
+      live = false;
+      stop();
+    };
+  },
+  shallowEqual,
+);
+
+/** The current network status. Re-renders on every change. */
+export function useNetwork(): NetworkStatus {
+  return useLiveValue(current);
+}

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

@@ -0,0 +1,43 @@
+import { defineWebPlugin } from "../../../packages/core/src/index.ts";
+import type { ConnectionType, NetworkApi, NetworkEvents, NetworkStatus } from "./index.ts";
+
+interface NetworkInformation extends EventTarget {
+  type?: string;
+}
+
+function connection(): NetworkInformation | undefined {
+  return (navigator as Navigator & { connection?: NetworkInformation }).connection;
+}
+
+export function readStatus(): NetworkStatus {
+  const connected = navigator.onLine !== false;
+  if (!connected) return { connected, type: "none" };
+  const types: Record<string, ConnectionType> = { wifi: "wifi", cellular: "cellular", ethernet: "ethernet" };
+  return { connected, type: types[connection()?.type ?? ""] ?? "unknown" };
+}
+
+export const web = defineWebPlugin<NetworkApi, NetworkEvents>({
+  methods: {
+    getStatus: async () => readStatus(),
+  },
+  events: {
+    change(emit) {
+      let last = readStatus();
+      const check = () => {
+        const next = readStatus();
+        if (next.connected === last.connected && next.type === last.type) return;
+        last = next;
+        emit(next);
+      };
+      const info = connection();
+      window.addEventListener("online", check);
+      window.addEventListener("offline", check);
+      info?.addEventListener("change", check);
+      return () => {
+        window.removeEventListener("online", check);
+        window.removeEventListener("offline", check);
+        info?.removeEventListener("change", check);
+      };
+    },
+  },
+});