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

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

@@ -0,0 +1,28 @@
+{
+  "id": "iap",
+  "apiVersion": 1,
+  "methods": [
+    "canMakePayments",
+    "getProducts",
+    "purchase",
+    "finish",
+    "getUnfinished",
+    "getEntitlements",
+    "restore",
+    "manageSubscriptions"
+  ],
+  "events": ["transaction"],
+  "codegen": true,
+  "web": null,
+  "desktop": null,
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "IapPlugin",
+    "frameworks": ["StoreKit"]
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.iap.IapPlugin",
+    "maven": ["com.android.billingclient:billing:9.1.0"]
+  }
+}

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

@@ -0,0 +1,206 @@
+import { definePlugin } from "../../../packages/core/src/index.ts";
+import { usePluginEvent } from "../../../packages/react/src/index.ts";
+
+/**
+ * iOS knows the kind; Google Play only knows one-time products and subscriptions ("oneTime": whether it
+ * is consumed is the app's decision, made at finish()).
+ */
+export type IapProductType = "consumable" | "nonConsumable" | "subscription" | "nonRenewingSubscription" | "oneTime";
+
+export type IapPeriodUnit = "day" | "week" | "month" | "year";
+
+export interface IapPeriod {
+  unit: IapPeriodUnit;
+  value: number;
+}
+
+/** freeTrial: free for `cycles` periods; payAsYouGo: `price` per period for `cycles` periods; payUpFront: `price` once for the whole span; recurring: the regular price, until cancelled. */
+export type IapPaymentMode = "freeTrial" | "payAsYouGo" | "payUpFront" | "recurring";
+
+export interface IapPricingPhase {
+  displayPrice: string;
+  price: number;
+  currency: string;
+  /** Absent for a one-time price. */
+  period?: IapPeriod;
+  /** How many periods the phase lasts (0 for recurring). */
+  cycles: number;
+  mode: IapPaymentMode;
+}
+
+/** base: a subscription's regular plan or a one-time product's price. The others are discounts. */
+export type IapOfferKind = "base" | "introductory" | "promotional" | "winBack" | "oneTime";
+
+export interface IapOffer {
+  kind: IapOfferKind;
+  /** Android: pass as purchase({ offerToken }) to buy this offer. */
+  token?: string;
+  /** iOS: the promotional or win-back offer's id. Android: the offer id (absent for a base plan). */
+  id?: string;
+  /** Android subscriptions: the base plan this offer belongs to. */
+  basePlanId?: string;
+  /** Android: the tags set in Play Console. */
+  tags?: string[];
+  phases: IapPricingPhase[];
+}
+
+export interface IapProduct {
+  id: string;
+  type: IapProductType;
+  title: string;
+  description: string;
+  /** The regular price, formatted for the store's locale and currency. */
+  displayPrice: string;
+  price: number;
+  /** ISO 4217. */
+  currency: string;
+  /** Subscriptions: the regular billing period. */
+  subscriptionPeriod?: IapPeriod;
+  /** iOS subscriptions: the subscription group. */
+  subscriptionGroupId?: string;
+  /** iOS subscriptions: whether this account may still take the introductory offer. */
+  introOfferEligible?: boolean;
+  offers: IapOffer[];
+}
+
+export interface IapGetProductsArgs {
+  ids: string[];
+  /** Android: which kind to look up; both when absent (two queries). iOS ignores it. */
+  type?: "inapp" | "subs";
+}
+
+export interface IapGetProductsResult {
+  products: IapProduct[];
+  /** Ids the store did not return (unknown, not approved yet, or not available in this storefront). */
+  invalidIds: string[];
+}
+
+/** An iOS promotional offer: its id and the compact JWS your server signed (App Store Server Library). */
+export interface IapPromotionalOffer {
+  offerId: string;
+  jws: string;
+}
+
+export interface IapPurchaseArgs {
+  productId: string;
+  /** Android: the offer to buy (IapOffer.token). Default: a subscription's first base plan, a one-time product's first offer. */
+  offerToken?: string;
+  /** iOS: a promotional offer signed by your server. Introductory offers apply by themselves. */
+  promotionalOffer?: IapPromotionalOffer;
+  /**
+   * Ties the purchase to your user, so the server can check who bought it. iOS: appAccountToken, which
+   * must be a UUID. Android: obfuscatedAccountId (at most 64 characters; do not send personal data).
+   */
+  accountId?: string;
+  /** iOS consumables: how many (default 1). */
+  quantity?: number;
+}
+
+/** purchased: paid, verify and finish it. pending: waiting for payment or approval; it arrives later as a "transaction" event. revoked: refunded or taken away (iOS). */
+export type IapTransactionState = "purchased" | "pending" | "revoked";
+
+/** What your server checks. iOS: jws (App Store Server API) or, for old servers, appReceipt. Android: purchaseToken with packageName (Google Play Developer API). */
+export interface IapVerification {
+  /** iOS: the transaction's signed JWS. */
+  jws?: string;
+  transactionId?: string;
+  originalTransactionId?: string;
+  /** iOS: the app receipt (base64), for servers that still use verifyReceipt. Absent when the device has none. */
+  appReceipt?: string;
+  /** Android. */
+  purchaseToken?: string;
+  /** Android: absent while pending. */
+  orderId?: string;
+  packageName?: string;
+  /** Android: the purchase JSON and its signature (the app's license key checks it). */
+  originalJson?: string;
+  signature?: string;
+}
+
+export interface IapTransaction {
+  /** What finish() takes. iOS: the transaction id. Android: the purchase token. */
+  id: string;
+  productId: string;
+  state: IapTransactionState;
+  /** Milliseconds since the epoch. */
+  purchaseDate: number;
+  quantity: number;
+  /** iOS: the first transaction of this subscription or purchase. */
+  originalId?: string;
+  /** iOS subscriptions. */
+  expirationDate?: number;
+  /** iOS: when it was refunded or revoked. */
+  revocationDate?: number;
+  /** Android subscriptions. */
+  autoRenewing?: boolean;
+  /** Android: already acknowledged or consumed (finished). */
+  acknowledged?: boolean;
+  /** What purchase() was given as accountId. */
+  accountId?: string;
+  /** iOS: "Production", "Sandbox" or "Xcode". */
+  environment?: string;
+  /** iOS: StoreKit's own signature check passed. Your server must still check it. */
+  verified?: boolean;
+  verification: IapVerification;
+}
+
+export type IapPurchaseStatus = "purchased" | "pending";
+
+export interface IapPurchaseResult {
+  status: IapPurchaseStatus;
+  /** Present when purchased. */
+  transaction?: IapTransaction;
+}
+
+export interface IapFinishArgs {
+  /** IapTransaction.id. */
+  transactionId: string;
+  /** Android: consume it so it can be bought again (consumables). Otherwise it is acknowledged. iOS finishes either way. */
+  consume?: boolean;
+}
+
+export interface IapTransactionsResult {
+  transactions: IapTransaction[];
+}
+
+export interface IapApi {
+  /** False when purchases are turned off (iOS Screen Time) or Google Play billing is unavailable. */
+  canMakePayments(): Promise<{ value: boolean }>;
+  getProducts(args: IapGetProductsArgs): Promise<IapGetProductsResult>;
+  /** Shows the store's purchase sheet. Rejects with CANCELLED when the user closes it. */
+  purchase(args: IapPurchaseArgs): Promise<IapPurchaseResult>;
+  /** After your server verified it: finishes (iOS), consumes or acknowledges (Android) the transaction. */
+  finish(args: IapFinishArgs): Promise<void>;
+  /** Paid transactions that were not finished yet: verify and finish them at startup. */
+  getUnfinished(): Promise<IapTransactionsResult>;
+  /** What the user owns now: non-consumables, active subscriptions and (Android) unconsumed one-time products. */
+  getEntitlements(): Promise<IapTransactionsResult>;
+  /** A "Restore purchases" button: iOS syncs with the App Store (may ask to sign in), then answers like getEntitlements. */
+  restore(): Promise<IapTransactionsResult>;
+  /** Opens the store's subscription management (iOS sheet, Google Play page). */
+  manageSubscriptions(args: { productId?: string }): Promise<void>;
+}
+
+export interface IapEvents {
+  /** A transaction that is not the answer to a purchase() call. Verify and finish it like one. */
+  transaction: IapTransaction;
+}
+
+export const iap = definePlugin<IapApi, IapEvents>("iap", {
+  methods: [
+    "canMakePayments",
+    "getProducts",
+    "purchase",
+    "finish",
+    "getUnfinished",
+    "getEntitlements",
+    "restore",
+    "manageSubscriptions",
+  ],
+  events: ["transaction"],
+});
+
+/** Subscribes to transactions for the component's lifetime. */
+export function useIapTransaction(handler: (transaction: IapTransaction) => void): void {
+  usePluginEvent(iap, "transaction", handler);
+}

package/vendor/@akanjs/native/plugins/keep-awake/android/KeepAwakePlugin.kt

@@ -0,0 +1,48 @@
+package com.akanjs.plugins.keepawake
+
+import android.view.WindowManager
+import com.akanjs.runtime.AkanNativeDocumentScope
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+import com.akanjs.runtime.AkanNativeVoidReply
+
+/**
+ * FLAG_KEEP_SCREEN_ON on the activity window (plugins.md §4.1). No WAKE_LOCK permission is needed:
+ * the flag only applies while the window is visible, so the system undoes it in the background by
+ * itself. The shell handles configuration changes without recreating the activity, so the flag
+ * survives rotation and dark mode switches. It belongs to the page that set it (architecture review:
+ * document scope, like the web's Wake Lock): a reload or navigation clears it (AkanNativeDocumentScope.own).
+ * Entry points run on the main thread, as window flags require.
+ * The result types come from the generated KeepAwakePluginSpec (PL-10).
+ */
+class KeepAwakePlugin(private val context: AkanNativePluginContext) : KeepAwakePluginSpec {
+    /** The page holding the flag and its token there. */
+    private var holder: AkanNativeDocumentScope? = null
+    private var token = 0L
+
+    override fun keepAwake(reply: AkanNativeVoidReply) {
+        val window = context.activity.window
+        window.addFlags(FLAG)
+        val document = reply.call.document
+        if (document != null && document !== holder) {
+            holder?.disown(token)
+            holder = document
+            token = document.own { window.clearFlags(FLAG) }
+        }
+        reply.resolve()
+    }
+
+    override fun allowSleep(reply: AkanNativeVoidReply) {
+        holder?.disown(token)
+        holder = null
+        context.activity.window.clearFlags(FLAG)
+        reply.resolve()
+    }
+
+    override fun isKeptAwake(reply: AkanNativeReply<KeepAwakeIsKeptAwakeResult>) =
+        reply.resolve(KeepAwakeIsKeptAwakeResult(value = (context.activity.window.attributes.flags and FLAG) != 0))
+
+    private companion object {
+        const val FLAG = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+    }
+}

package/vendor/@akanjs/native/plugins/keep-awake/ios/KeepAwakePlugin.swift

@@ -0,0 +1,36 @@
+import UIKit
+
+/// UIApplication.isIdleTimerDisabled (plugins.md §4.1, the flag Expo's keep-awake sets as well).
+/// The flag belongs to the page that set it (architecture review: document scope, like the web's
+/// Wake Lock): a reload, a navigation or the window going away clears it (AkanNativeDocument.own). The
+/// system ignores it while the app is in the background, so nothing needs to be undone on backgrounding.
+/// The result types come from the generated KeepAwakePluginSpec (PL-10).
+final class KeepAwakePlugin: KeepAwakePluginSpec {
+    static let id = "keep-awake"
+    /// The page holding the flag and its token there.
+    private weak var holder: AkanNativeDocument?
+    private var token = 0
+
+    init(context: AkanNativePluginContext) {}
+
+    func keepAwake(_ reply: AkanNativeReply<Void>) {
+        UIApplication.shared.isIdleTimerDisabled = true
+        if let document = reply.call.document, document !== holder {
+            holder?.disown(token)
+            holder = document
+            token = document.own { UIApplication.shared.isIdleTimerDisabled = false }
+        }
+        reply.resolve()
+    }
+
+    func allowSleep(_ reply: AkanNativeReply<Void>) {
+        holder?.disown(token)
+        holder = nil
+        UIApplication.shared.isIdleTimerDisabled = false
+        reply.resolve()
+    }
+
+    func isKeptAwake(_ reply: AkanNativeReply<KeepAwakeIsKeptAwakeResult>) {
+        reply.resolve(KeepAwakeIsKeptAwakeResult(value: UIApplication.shared.isIdleTimerDisabled))
+    }
+}

package/vendor/@akanjs/native/plugins/keep-awake/native-plugin.json

@@ -0,0 +1,17 @@
+{
+  "id": "keep-awake",
+  "apiVersion": 1,
+  "methods": ["keepAwake", "allowSleep", "isKeptAwake"],
+  "events": [],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": "./src/desktop.ts",
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "KeepAwakePlugin"
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.keepawake.KeepAwakePlugin"
+  }
+}

package/vendor/@akanjs/native/plugins/keep-awake/src/desktop.ts

@@ -0,0 +1,127 @@
+
+
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import { type DesktopContext, defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import type { KeepAwakeApi } from "./index.ts";
+
+export const CAFFEINATE = "/usr/bin/caffeinate";
+
+export interface Child {
+  readonly exitCode: number | null;
+  kill(): void;
+  readonly exited: Promise<number>;
+}
+
+export type Spawner = (argv: string[]) => Child;
+
+const spawnChild: Spawner = (argv) => Bun.spawn(argv, { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+
+/**
+ * The pages that asked (architecture review: keep-awake is document scope, like the web's Wake
+ * Lock). The display stays on while one of them is loaded and has not called allowSleep; a page
+ * that reloads, navigates away or whose window closes lets go by itself.
+ */
+function holders(release: () => Promise<void>) {
+  const pages = new Map<string, () => void>();
+  const key = (ctx: DesktopContext) => `${ctx.window ?? 1}:${ctx.document?.id ?? ""}`;
+  const letGo = async (page: string) => {
+    if (!pages.delete(page) || pages.size > 0) return;
+    await release();
+  };
+  return {
+    get held() {
+      return pages.size > 0;
+    },
+    /** Records the calling page; true when it is the first holder. */
+    add(ctx: DesktopContext): boolean {
+      const page = key(ctx);
+      if (pages.has(page)) return false;
+      const first = pages.size === 0;
+      pages.set(page, () => {});
+      const disown = ctx.document?.own(() => letGo(page));
+      if (disown) pages.set(page, disown);
+      return first;
+    },
+    /** The first holder's request failed: forget it again. */
+    drop(ctx: DesktopContext) {
+      const page = key(ctx);
+      pages.get(page)?.();
+      pages.delete(page);
+    },
+    remove(ctx: DesktopContext): Promise<void> {
+      const page = key(ctx);
+      pages.get(page)?.();
+      return letGo(page);
+    },
+  };
+}
+
+/** Windows and Linux: the shell's power request. */
+function shellKeepAwake() {
+  let shell: DesktopContext["shell"] | null = null;
+  const pages = holders(async () => {
+    
+    await shell?.("power.allowSleep").catch((error) =>
+      console.error("[akan-native] keep-awake: power.allowSleep failed", error),
+    );
+  });
+  return defineDesktopPlugin<KeepAwakeApi>({
+    id: "keep-awake",
+    methods: {
+      async keepAwake(_args, ctx: DesktopContext) {
+        shell = ctx.shell;
+        if (!pages.add(ctx)) return;
+        try {
+          await ctx.shell("power.preventSleep");
+        } catch (error) {
+          pages.drop(ctx);
+          throw error;
+        }
+      },
+      allowSleep: (_args, ctx: DesktopContext) => pages.remove(ctx),
+      isKeptAwake: () => ({ value: pages.held }),
+    },
+  });
+}
+
+/**
+ * `spawn` is replaceable so tests can check the command without keeping the Mac awake, `platform`
+ * so they can check the shell ops of Windows and Linux on any OS.
+ */
+export function createDesktopKeepAwake(
+  spawn: Spawner = spawnChild,
+  pid: number = process.pid,
+  platform: NodeJS.Platform = process.platform,
+) {
+  if (platform !== "darwin") return shellKeepAwake();
+  let child: Child | null = null;
+  const alive = () => child !== null && child.exitCode === null;
+  const pages = holders(async () => {
+    const current = child;
+    child = null;
+    if (!current || current.exitCode !== null) return;
+    current.kill();
+    await current.exited;
+  });
+
+  return defineDesktopPlugin<KeepAwakeApi>({
+    id: "keep-awake",
+    methods: {
+      keepAwake(_args, ctx: DesktopContext) {
+        pages.add(ctx);
+        if (alive()) return;
+        try {
+          child = spawn([CAFFEINATE, "-d", "-i", "-w", String(pid)]);
+        } catch (error) {
+          child = null;
+          pages.drop(ctx);
+          throw new AkanNativeError("INTERNAL", `cannot start ${CAFFEINATE}: ${(error as Error).message}`);
+        }
+      },
+      allowSleep: (_args, ctx: DesktopContext) => pages.remove(ctx),
+      isKeptAwake: () => ({ value: alive() }),
+    },
+  });
+}
+
+export default createDesktopKeepAwake();

package/vendor/@akanjs/native/plugins/keep-awake/src/index.ts

@@ -0,0 +1,79 @@
+
+
+import * as React from "react";
+import { definePlugin } from "../../../packages/core/src/index.ts";
+import { web } from "./web.ts";
+
+/**
+ * Keeps the screen on (plugins.md §4.1). The state belongs to the page, like the web's Screen Wake
+ * Lock (architecture review, 2026-09-26): a reload, a navigation or the window closing lets the
+ * display sleep again on every platform. On the desktop each window's page holds its own request;
+ * the display stays on while one holds it. Idempotent: calling keepAwake twice needs one allowSleep.
+ */
+export interface KeepAwakeApi {
+  /**
+   * Stops the display from dimming and sleeping while the app is in front. Rejects UNSUPPORTED
+   * on browsers without the Screen Wake Lock API and on Linux sessions without an inhibit service
+   * (xdg-desktop-portal or org.freedesktop.ScreenSaver, which GNOME and KDE provide), and
+   * PERMISSION_DENIED when the browser refuses it (e.g. a Permissions-Policy, or low battery mode).
+   */
+  keepAwake(): Promise<void>;
+  /** Lets the display sleep again. Always resolves, also when keepAwake was never called. */
+  allowSleep(): Promise<void>;
+  /**
+   * Whether keepAwake is in effect. On the web it stays true while the page is hidden: the browser
+   * releases the lock then and it is requested again when the page becomes visible.
+   */
+  isKeptAwake(): Promise<{ value: boolean }>;
+}
+
+export const keepAwake = definePlugin<KeepAwakeApi>("keep-awake", {
+  methods: ["keepAwake", "allowSleep", "isKeptAwake"],
+  web,
+});
+
+let holders = 0;
+let held = false;
+let queue: Promise<unknown> = Promise.resolve();
+
+function sync(): void {
+  const want = holders > 0;
+  if (want === held) return;
+  held = want;
+  queue = queue
+    .then(() => (want ? keepAwake.keepAwake() : keepAwake.allowSleep()))
+    .catch((error) => console.warn(`[akan-native] keep-awake: ${want ? "keepAwake" : "allowSleep"} failed`, error));
+}
+
+/**
+ * Keeps the screen on until the returned function is called (once per holder). The first holder
+ * calls keepAwake, the last release calls allowSleep. Do not mix with direct keepAwake()/allowSleep()
+ * calls: holders only know about each other. Resolves when the host has applied the change.
+ */
+export function holdKeepAwake(): () => Promise<void> {
+  holders++;
+  sync();
+  let released = false;
+  return () => {
+    if (!released) {
+      released = true;
+      holders--;
+      return new Promise<void>((resolve) =>
+        queueMicrotask(() => {
+          sync();
+          void queue.then(() => resolve());
+        }),
+      );
+    }
+    return queue.then(() => undefined);
+  };
+}
+
+/** Keeps the screen on while the component is mounted and `enabled` (a holder, see holdKeepAwake). */
+export function useKeepAwake(enabled = true): void {
+  React.useEffect(() => {
+    if (!enabled) return;
+    const release = holdKeepAwake();
+    return () => void release();
+  }, [enabled]);
+}

package/vendor/@akanjs/native/plugins/keep-awake/src/web.ts

@@ -0,0 +1,78 @@
+import { AkanNativeError, defineWebPlugin } from "../../../packages/core/src/index.ts";
+import type { KeepAwakeApi } from "./index.ts";
+
+interface Sentinel extends EventTarget {
+  readonly released: boolean;
+  release(): Promise<void>;
+}
+
+interface WakeLock {
+  request(type: "screen"): Promise<Sentinel>;
+}
+
+let wanted = false;
+let sentinel: Sentinel | null = null;
+let pending: Promise<Sentinel> | null = null;
+
+function wakeLock(): WakeLock | undefined {
+  return typeof navigator === "undefined" ? undefined : (navigator as Navigator & { wakeLock?: WakeLock }).wakeLock;
+}
+
+function request(lock: WakeLock): Promise<Sentinel> {
+  if (sentinel && !sentinel.released) return Promise.resolve(sentinel);
+  pending ??= lock.request("screen").then(
+    (next) => {
+      pending = null;
+      if (!wanted) {
+        void next.release(); 
+        return next;
+      }
+      sentinel = next;
+      return next;
+    },
+    (error: unknown) => {
+      pending = null;
+      throw error;
+    },
+  );
+  return pending;
+}
+
+function onVisibility(): void {
+  const lock = wakeLock();
+  if (!wanted || !lock || document.visibilityState !== "visible") return;
+  request(lock).catch((error) => console.warn("[akan-native] keep-awake: could not re-acquire the wake lock", error));
+}
+
+export const web = defineWebPlugin<KeepAwakeApi>({
+  methods: {
+    keepAwake() {
+      const lock = wakeLock();
+      if (!lock)
+        return Promise.reject(
+          new AkanNativeError("UNSUPPORTED", "this browser has no Screen Wake Lock API (navigator.wakeLock)"),
+        );
+      const first = !wanted;
+      wanted = true;
+      if (first) document.addEventListener("visibilitychange", onVisibility);
+      
+      if (document.visibilityState !== "visible") return Promise.resolve();
+      return request(lock).then(
+        () => undefined,
+        (error: unknown) => {
+          wanted = false;
+          document.removeEventListener("visibilitychange", onVisibility);
+          throw AkanNativeError.from(error);
+        },
+      );
+    },
+    async allowSleep() {
+      if (wanted) document.removeEventListener("visibilitychange", onVisibility);
+      wanted = false;
+      const current = sentinel;
+      sentinel = null;
+      if (current && !current.released) await current.release();
+    },
+    isKeptAwake: async () => ({ value: wanted }),
+  },
+});