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

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

@@ -0,0 +1,155 @@
+import {
+  AkanNativeError,
+  createLiveValue,
+  definePlugin,
+  type ErrorCode,
+  type LiveValue,
+} from "../../../packages/core/src/index.ts";
+import { useLiveValue } from "../../../packages/react/src/index.ts";
+import { web } from "./web.ts";
+
+export type PermissionState = "granted" | "denied" | "prompt" | "prompt-with-rationale";
+
+export interface LocationPermission {
+  /** "denied" also covers location services turned off system-wide (iOS reports it that way). */
+  location: PermissionState;
+  /**
+   * Whether positions are precise: iOS Precise Location on, Android ACCESS_FINE_LOCATION granted.
+   * false means approximate (a few km). null when location is not granted or the platform cannot tell (web).
+   */
+  precise: boolean | null;
+}
+
+/** A W3C GeolocationPosition, flattened. Distances in meters, angles in degrees, speed in m/s. */
+export interface Position {
+  latitude: number;
+  longitude: number;
+  /** Radius of 68% confidence around latitude/longitude. */
+  accuracy: number;
+  /** Height above the WGS84 ellipsoid (as W3C and Android report it; iOS converts from its mean-sea-level value). */
+  altitude: number | null;
+  altitudeAccuracy: number | null;
+  /** Direction of travel, clockwise from true north. null when unknown or not moving. */
+  heading: number | null;
+  speed: number | null;
+  /** When the fix was taken, ms since the Unix epoch. */
+  timestamp: number;
+}
+
+/**
+ * Numbers must be finite on iOS and Android: the bridge is JSON, where Infinity becomes null, i.e.
+ * the default. For "any cached fix" pass a large number such as 86_400_000 (a day).
+ */
+export interface PositionOptions {
+  /**
+   * Ask for the best accuracy (GPS) instead of a battery-friendly fix (~100 m). Default false.
+   * On Android a balanced request never turns on GPS: without network location (the emulator)
+   * it only gets a fix another request produced recently, or times out.
+   */
+  enableHighAccuracy?: boolean;
+  /** Give up after this many ms with NOT_FOUND, counted after the permission prompt. Default 30000; Android ends a single request after 30 s. */
+  timeout?: number;
+  /** Accept a cached fix up to this many ms old. Default 0 (always a new fix). */
+  maximumAge?: number;
+}
+
+/**
+ * getCurrentPosition() asks for permission first when it was never asked, like the W3C API.
+ * It rejects with
+ * - PERMISSION_DENIED: the user denied location (or turned it off, on iOS)
+ * - NOT_FOUND: no position: timeout, location turned off (Android, web), no provider
+ * - INTERNAL: NSLocationWhenInUseUsageDescription missing (iOS) and other failures
+ * - UNSUPPORTED: macOS (WKWebView has no public geolocation permission hook and CoreLocation
+ *   would need native desktop code) and browsers without navigator.geolocation (insecure context)
+ */
+export interface GeolocationApi {
+  getCurrentPosition(options?: PositionOptions): Promise<Position>;
+  checkPermission(): Promise<LocationPermission>;
+  /** Shows the system prompt when the state is "prompt" or "prompt-with-rationale"; otherwise returns the state. */
+  requestPermission(): Promise<LocationPermission>;
+}
+
+export interface GeolocationError {
+  code: ErrorCode;
+  message: string;
+}
+
+/**
+ * Position updates run while someone listens: "position" at balanced accuracy, and
+ * "highAccuracyPosition" with GPS. While both have listeners the host runs one high-accuracy
+ * watch and sends each fix to both. Updates stop while the app is in the background.
+ * "error" reports watch failures (permission denied or revoked, location turned off); it does not
+ * start a watch by itself.
+ */
+export interface GeolocationEvents {
+  position: Position;
+  highAccuracyPosition: Position;
+  error: GeolocationError;
+}
+
+export const geolocation = definePlugin<GeolocationApi, GeolocationEvents>("geolocation", {
+  methods: ["getCurrentPosition", "checkPermission", "requestPermission"],
+  events: ["position", "highAccuracyPosition", "error"],
+  web,
+});
+
+export interface WatchOptions {
+  enableHighAccuracy?: boolean;
+  onError?: (error: AkanNativeError) => void;
+}
+
+/**
+ * Calls `onPosition` for every new fix until the returned function is called. Like W3C
+ * watchPosition, it asks for permission first when it was never asked.
+ */
+export function watchPosition(onPosition: (position: Position) => void, options: WatchOptions = {}): () => void {
+  
+  const { onError } = options;
+  const stopError = onError
+    ? geolocation.listen("error", (e) => onError(new AkanNativeError(e.code, e.message)))
+    : null;
+  const stopPosition = geolocation.listen(options.enableHighAccuracy ? "highAccuracyPosition" : "position", onPosition);
+  return () => {
+    stopPosition();
+    stopError?.();
+  };
+}
+
+export interface GeolocationState {
+  /** The latest fix, null until the first one. */
+  position: Position | null;
+  /** The latest failure; cleared by the next fix. */
+  error: AkanNativeError | null;
+}
+
+const watches = new Map<boolean, LiveValue<GeolocationState>>();
+
+function watch(high: boolean): LiveValue<GeolocationState> {
+  let live = watches.get(high);
+  if (!live) {
+    const created: LiveValue<GeolocationState> = createLiveValue<GeolocationState>(
+      { position: null, error: null },
+      (set) => {
+        if (geolocation.eventImplementation(high ? "highAccuracyPosition" : "position") === "none") {
+          set({
+            position: null,
+            error: new AkanNativeError("UNSUPPORTED", "geolocation is not supported on this platform"),
+          });
+          return;
+        }
+        return watchPosition((position) => set({ position, error: null }), {
+          enableHighAccuracy: high,
+          onError: (error) => set({ position: created.get().position, error }),
+        });
+      },
+    );
+    live = created;
+    watches.set(high, created);
+  }
+  return live;
+}
+
+/** Watches the position while the component is mounted. Components with the same accuracy share one watch. */
+export function useGeolocation(options: { enableHighAccuracy?: boolean } = {}): GeolocationState {
+  return useLiveValue(watch(options.enableHighAccuracy === true));
+}

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

@@ -0,0 +1,132 @@
+import { AkanNativeError, defineWebPlugin } from "../../../packages/core/src/index.ts";
+import type {
+  GeolocationApi,
+  GeolocationError,
+  GeolocationEvents,
+  LocationPermission,
+  PermissionState,
+  Position,
+  PositionOptions,
+} from "./index.ts";
+
+export const DEFAULT_TIMEOUT = 30_000;
+
+function api(): Geolocation {
+  const geo = typeof navigator === "undefined" ? undefined : navigator.geolocation;
+  if (!geo) throw new AkanNativeError("UNSUPPORTED", "navigator.geolocation is not available (insecure context?)");
+  return geo;
+}
+
+const finite = (value: number | null | undefined): number | null =>
+  typeof value === "number" && Number.isFinite(value) ? value : null;
+
+export function toPosition(p: GeolocationPosition): Position {
+  const c = p.coords;
+  return {
+    latitude: c.latitude,
+    longitude: c.longitude,
+    accuracy: c.accuracy,
+    altitude: finite(c.altitude),
+    altitudeAccuracy: finite(c.altitudeAccuracy),
+    heading: finite(c.heading), // NaN while standing still
+    speed: finite(c.speed),
+    timestamp: p.timestamp,
+  };
+}
+
+/** W3C GeolocationPositionError codes: 1 PERMISSION_DENIED, 2 POSITION_UNAVAILABLE, 3 TIMEOUT. */
+export function toError(error: { code: number; message?: string }): AkanNativeError {
+  if (error.code === 1) return new AkanNativeError("PERMISSION_DENIED", error.message || "location access was denied");
+  if (error.code === 3) return new AkanNativeError("NOT_FOUND", error.message || "no position within the timeout");
+  return new AkanNativeError("NOT_FOUND", error.message || "the position is unavailable");
+}
+
+export function positionOptions(options: PositionOptions | undefined): globalThis.PositionOptions {
+  const o = options ?? {};
+  const ms = (name: "timeout" | "maximumAge", fallback: number) => {
+    const value = o[name];
+    if (value === undefined || value === null) return fallback;
+    if (typeof value !== "number" || Number.isNaN(value) || value < 0)
+      throw new AkanNativeError("INVALID_ARGS", `${name} must be a number of ms >= 0`);
+    return value;
+  };
+  return {
+    enableHighAccuracy: o.enableHighAccuracy === true,
+    timeout: ms("timeout", DEFAULT_TIMEOUT),
+    maximumAge: ms("maximumAge", 0),
+  };
+}
+
+function current(options: globalThis.PositionOptions): Promise<Position> {
+  const geo = api();
+  return new Promise((resolve, reject) =>
+    geo.getCurrentPosition(
+      (p) => resolve(toPosition(p)),
+      (e) => reject(toError(e)),
+      options,
+    ),
+  );
+}
+
+async function state(): Promise<PermissionState> {
+  try {
+    return (await navigator.permissions.query({ name: "geolocation" })).state;
+  } catch {
+    return "prompt"; 
+  }
+}
+
+let reportError: ((error: GeolocationError) => void) | null = null;
+const report = (error: AkanNativeError) => reportError?.({ code: error.code, message: error.message });
+
+function watchSource(enableHighAccuracy: boolean) {
+  return (emit: (position: Position) => void) => {
+    let geo: Geolocation;
+    try {
+      geo = api();
+    } catch (error) {
+      report(AkanNativeError.from(error));
+      return () => {};
+    }
+    const id = geo.watchPosition(
+      (p) => emit(toPosition(p)),
+      (e) => report(toError(e)),
+      { enableHighAccuracy, maximumAge: 0 },
+    );
+    return () => geo.clearWatch(id);
+  };
+}
+
+export const web = defineWebPlugin<GeolocationApi, GeolocationEvents>({
+  methods: {
+    getCurrentPosition: async (options) => current(positionOptions(options)),
+    checkPermission: async (): Promise<LocationPermission> => {
+      api();
+      return { location: await state(), precise: null };
+    },
+    async requestPermission(): Promise<LocationPermission> {
+      api();
+      const before = await state();
+      if (before === "granted" || before === "denied") return { location: before, precise: null };
+      
+      try {
+        await current({ enableHighAccuracy: false, timeout: DEFAULT_TIMEOUT, maximumAge: Infinity });
+        return { location: "granted", precise: null };
+      } catch (error) {
+        if (error instanceof AkanNativeError && error.code === "PERMISSION_DENIED")
+          return { location: "denied", precise: null };
+        return { location: await state(), precise: null }; 
+      }
+    },
+  },
+  events: {
+    position: watchSource(false),
+    highAccuracyPosition: watchSource(true),
+    error(emit) {
+      reportError = emit;
+      return () => {
+        if (reportError === emit) reportError = null;
+      };
+    },
+  },
+});

package/vendor/@akanjs/native/plugins/global-shortcut/native-plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "global-shortcut",
+  "apiVersion": 1,
+  "methods": ["register", "unregister", "unregisterAll", "isRegistered", "list"],
+  "events": ["pressed"],
+  "web": null,
+  "desktop": "./src/desktop.ts",
+  "ios": null,
+  "android": null
+}

package/vendor/@akanjs/native/plugins/global-shortcut/src/desktop.ts

@@ -0,0 +1,36 @@
+
+
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import { defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import type { GlobalShortcutApi, GlobalShortcutEvents } from "./index.ts";
+
+function accelerator(value: unknown): string {
+  if (typeof value !== "string" || value.trim() === "")
+    throw new AkanNativeError("INVALID_ARGS", 'accelerator must be a string like "CmdOrCtrl+Shift+K"');
+  return value;
+}
+
+export default defineDesktopPlugin<GlobalShortcutApi, GlobalShortcutEvents>({
+  id: "global-shortcut",
+  methods: {
+    register: (args, ctx) =>
+      ctx.shell("hotkey.register", { accelerator: accelerator(args?.accelerator) }) as Promise<{ accelerator: string }>,
+    unregister: (args, ctx) =>
+      ctx.shell("hotkey.unregister", { accelerator: accelerator(args?.accelerator) }) as Promise<{ removed: boolean }>,
+    unregisterAll: async (_args, ctx) => {
+      await ctx.shell("hotkey.unregisterAll");
+    },
+    isRegistered: (args, ctx) =>
+      ctx.shell("hotkey.isRegistered", { accelerator: accelerator(args?.accelerator) }) as Promise<{
+        registered: boolean;
+      }>,
+    list: (_args, ctx) => ctx.shell("hotkey.list") as Promise<string[]>,
+  },
+  events: {
+    
+    pressed: (emit, ctx) =>
+      ctx.onNativeEvent("hotkey", (e) => {
+        emit({ accelerator: e.accelerator as string }, "focused");
+      }),
+  },
+});

package/vendor/@akanjs/native/plugins/global-shortcut/src/index.ts

@@ -0,0 +1,55 @@
+import { definePlugin } from "../../../packages/core/src/index.ts";
+
+/**
+ * System-wide keyboard shortcuts that reach the app even when another app is in front
+ * (plugins.md §5).
+ *
+ * - Accelerators: modifiers plus one key joined by "+", e.g. "CmdOrCtrl+Shift+K", "Alt+F12".
+ *   Modifiers: Cmd, Ctrl, CmdOrCtrl (Command on macOS), Alt/Option, Shift. Keys: A–Z, 0–9,
+ *   F1–F20, punctuation, Space, Tab, Enter, Escape, Backspace, Delete, arrows, Home, End,
+ *   PageUp, PageDown, Num0–Num9.
+ * - macOS: Carbon hot keys, no permission needed. Keys are positions on the US layout. A
+ *   combination another app registered fails with an error; a system shortcut (Cmd+Space,
+ *   Cmd+Tab) may register and never fire.
+ * - Shortcuts belong to the app: they stay registered when the page reloads, and registering
+ *   one the app already has succeeds. `pressed` goes to the window the user was in last.
+ * - Windows: RegisterHotKey. CmdOrCtrl is Ctrl and Cmd the Windows key; some combinations
+ *   (Win+L, Ctrl+Alt+Del) never reach an app.
+ * - Linux: X11 only (XGrabKey), with the same rules. On Wayland register() rejects UNSUPPORTED:
+ *   GNOME and KDE offer global shortcuts there only through the GlobalShortcuts portal.
+ * - Web, iOS and Android: UNSUPPORTED.
+ */
+export interface GlobalShortcutApi {
+  /** Resolves with the canonical spelling ("CmdOrCtrl+Shift+K"). */
+  register(args: { accelerator: string }): Promise<{ accelerator: string }>;
+  unregister(args: { accelerator: string }): Promise<{ removed: boolean }>;
+  unregisterAll(): Promise<void>;
+  isRegistered(args: { accelerator: string }): Promise<{ registered: boolean }>;
+  /** The registered accelerators, as they were written. */
+  list(): Promise<string[]>;
+}
+
+export interface GlobalShortcutEvents {
+  /** `accelerator` as it was registered. */
+  pressed: { accelerator: string };
+}
+
+export const globalShortcut = definePlugin<GlobalShortcutApi, GlobalShortcutEvents>("global-shortcut", {
+  methods: ["register", "unregister", "unregisterAll", "isRegistered", "list"],
+  events: ["pressed"],
+});
+
+/**
+ * Registers a shortcut and calls `handler` when it is pressed. The returned function stops
+ * listening and unregisters the shortcut.
+ */
+export async function onShortcut(accelerator: string, handler: () => void): Promise<() => Promise<void>> {
+  await globalShortcut.register({ accelerator });
+  const stop = globalShortcut.listen("pressed", (e) => {
+    if (e.accelerator === accelerator) handler();
+  });
+  return async () => {
+    stop();
+    await globalShortcut.unregister({ accelerator });
+  };
+}

package/vendor/@akanjs/native/plugins/haptics/android/HapticsPlugin.kt

@@ -0,0 +1,127 @@
+package com.akanjs.plugins.haptics
+
+import android.app.Activity
+import android.content.Context
+import android.media.AudioAttributes
+import android.os.Build
+import android.os.VibrationAttributes
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
+import android.provider.Settings
+import com.akanjs.runtime.AkanNativeErrorCode
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeVoidReply
+
+/**
+ * VibratorManager.defaultVibrator (API 31; the VIBRATOR_SERVICE vibrator below) with the VIBRATE
+ * permission (normal, granted at install).
+ * - impact / notification: composition primitives (API 30) where the vibrator supports them, else
+ *   predefined effects, which fall back to a generic buzz on their own. Both are tuned per device.
+ *   tauri-plugins-workspace/plugins/haptics/android/src/main/java/patterns (Impact.kt, Notification.kt)
+ *   plays amplitude waveforms instead, which turn into plain buzzes on vibrators without amplitude
+ *   control; its notification waveforms stay as the fallback here.
+ * - selection: EFFECT_TICK, the effect the framework uses for picker and clock ticks.
+ * - UI feedback is played with USAGE_TOUCH, so the user's "touch feedback" setting applies like
+ *   System Haptics does on iOS. Below API 33 the service does not apply that setting, so the plugin
+ *   reads it (Settings.System.HAPTIC_FEEDBACK_ENABLED) and plays with sonification audio
+ *   attributes, which API 30+ maps to USAGE_TOUCH. vibrate() is a plain one-shot, like
+ *   react-native VibrationModule.kt:26-34.
+ * - API 29 has no composition primitives (30; PRIMITIVE_LOW_TICK 31): predefined effects there.
+ * A device without a vibrator resolves and does nothing, like iOS without a Taptic Engine.
+ * Arguments arrive decoded and checked by the generated HapticsPluginSpec (PL-10).
+ */
+class HapticsPlugin(context: AkanNativePluginContext) : HapticsPluginSpec {
+    private val activity = context.activity
+    private val vibrator: Vibrator? =
+        if (Build.VERSION.SDK_INT >= 31) Api31.defaultVibrator(activity) else @Suppress("DEPRECATION") activity.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
+
+    private class Step(val primitive: Int, val scale: Float, val delay: Int = 0)
+
+    override fun impact(args: HapticsImpactArgs, reply: AkanNativeVoidReply) {
+        val effect = when (args.style ?: HapticsImpactStyle.MEDIUM) {
+            HapticsImpactStyle.LIGHT -> compose(Step(PRIMITIVE_CLICK, 0.4f)) ?: VibrationEffect.createPredefined(VibrationEffect.EFFECT_TICK)
+            HapticsImpactStyle.MEDIUM -> compose(Step(PRIMITIVE_CLICK, 0.7f)) ?: VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK)
+            HapticsImpactStyle.HEAVY -> compose(Step(PRIMITIVE_CLICK, 1f)) ?: VibrationEffect.createPredefined(VibrationEffect.EFFECT_HEAVY_CLICK)
+            HapticsImpactStyle.SOFT -> compose(Step(PRIMITIVE_LOW_TICK, 1f)) ?: VibrationEffect.createPredefined(VibrationEffect.EFFECT_TICK)
+            HapticsImpactStyle.RIGID -> compose(Step(PRIMITIVE_TICK, 1f)) ?: VibrationEffect.createPredefined(VibrationEffect.EFFECT_CLICK)
+        }
+        play(reply, effect, touch = true)
+    }
+
+    override fun notification(args: HapticsNotificationArgs, reply: AkanNativeVoidReply) {
+        val effect = when (args.type ?: HapticsNotificationType.SUCCESS) {
+            HapticsNotificationType.SUCCESS -> compose(Step(PRIMITIVE_CLICK, 0.5f), Step(PRIMITIVE_CLICK, 1f, 100))
+                ?: waveform(longArrayOf(0, 40, 100, 40), intArrayOf(0, 50, 0, 60))
+            HapticsNotificationType.WARNING -> compose(Step(PRIMITIVE_CLICK, 1f), Step(PRIMITIVE_CLICK, 0.5f, 150))
+                ?: waveform(longArrayOf(0, 40, 120, 60), intArrayOf(0, 40, 0, 60))
+            HapticsNotificationType.ERROR -> compose(Step(PRIMITIVE_CLICK, 1f), Step(PRIMITIVE_CLICK, 0.8f, 100), Step(PRIMITIVE_CLICK, 1f, 100))
+                ?: waveform(longArrayOf(0, 60, 100, 40, 80, 50), intArrayOf(0, 50, 0, 40, 0, 50))
+        }
+        play(reply, effect, touch = true)
+    }
+
+    override fun selection(reply: AkanNativeVoidReply) = play(reply, VibrationEffect.createPredefined(VibrationEffect.EFFECT_TICK), touch = true)
+
+    override fun vibrate(args: HapticsVibrateArgs, reply: AkanNativeVoidReply) {
+        val value = args.duration ?: 300.0
+        if (value < 1 || value > 10000) return reply.reject(AkanNativeErrorCode.INVALID_ARGS, "duration must be a number of milliseconds between 1 and 10000")
+        play(reply, VibrationEffect.createOneShot(Math.round(value), VibrationEffect.DEFAULT_AMPLITUDE), touch = false)
+    }
+
+    /** Primitives in sequence, or null when this Android or the vibrator cannot play every one of them. */
+    private fun compose(vararg steps: Step): VibrationEffect? {
+        val v = vibrator ?: return null
+        if (Build.VERSION.SDK_INT < 30) return null
+        if (Build.VERSION.SDK_INT < 31 && steps.any { it.primitive == PRIMITIVE_LOW_TICK }) return null
+        return Api30.compose(v, steps)
+    }
+
+    private fun waveform(timings: LongArray, amplitudes: IntArray): VibrationEffect =
+        VibrationEffect.createWaveform(timings, amplitudes, -1)
+
+    /** Plays [effect]; [touch] feedback follows the user's touch feedback setting. */
+    @Suppress("DEPRECATION")
+    private fun play(reply: AkanNativeVoidReply, effect: VibrationEffect, touch: Boolean) {
+        val v = vibrator
+        if (v == null || !v.hasVibrator()) return reply.resolve()
+        try {
+            when {
+                !touch -> v.vibrate(effect)
+                Build.VERSION.SDK_INT >= 33 -> Api33.vibrateTouch(v, effect)
+                Settings.System.getInt(activity.contentResolver, Settings.System.HAPTIC_FEEDBACK_ENABLED, 1) != 0 -> v.vibrate(effect, SONIFICATION)
+            }
+            reply.resolve()
+        } catch (e: SecurityException) {
+            reply.reject(AkanNativeErrorCode.PERMISSION_DENIED, "android.permission.VIBRATE is missing from the app manifest")
+        }
+    }
+
+    private object Api30 {
+        fun compose(v: Vibrator, steps: Array<out Step>): VibrationEffect? {
+            if (!v.areAllPrimitivesSupported(*steps.map { it.primitive }.toIntArray())) return null
+            val composition = VibrationEffect.startComposition()
+            for (step in steps) composition.addPrimitive(step.primitive, step.scale, step.delay)
+            return composition.compose()
+        }
+    }
+
+    private object Api31 {
+        fun defaultVibrator(activity: Activity): Vibrator? = activity.getSystemService(VibratorManager::class.java)?.defaultVibrator
+    }
+
+    private object Api33 {
+        fun vibrateTouch(v: Vibrator, effect: VibrationEffect) = v.vibrate(effect, VibrationAttributes.createForUsage(VibrationAttributes.USAGE_TOUCH))
+    }
+
+    private companion object {
+        /** The pre-33 stand-in for USAGE_TOUCH (VibrationAttributes.Builder(AudioAttributes) maps them). */
+        val SONIFICATION: AudioAttributes = AudioAttributes.Builder()
+            .setUsage(AudioAttributes.USAGE_ASSISTANCE_SONIFICATION)
+            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+            .build()
+        const val PRIMITIVE_CLICK = VibrationEffect.Composition.PRIMITIVE_CLICK
+        const val PRIMITIVE_TICK = VibrationEffect.Composition.PRIMITIVE_TICK
+        const val PRIMITIVE_LOW_TICK = VibrationEffect.Composition.PRIMITIVE_LOW_TICK
+    }
+}

package/vendor/@akanjs/native/plugins/haptics/ios/HapticsPlugin.swift

@@ -0,0 +1,127 @@
+import AudioToolbox
+import CoreHaptics
+import UIKit
+
+/// impact / notification / selection: UIKit feedback generators. They follow the user's System Haptics
+/// setting and do nothing without a Taptic Engine (simulator, iPad), so calls always resolve.
+/// - Generators are created once per kind with init(style:view:) / init(view:) (iOS 17.5; init() and
+///   init(style:) are marked API_TO_BE_DEPRECATED in the iOS 26 SDK, and are what iOS 16 to 17.4
+///   get). They attach to the web view, so one per call would pile up there.
+/// - prepare() right after firing keeps the Taptic Engine ready for the next call (a picker scrolled
+///   with selection()). tauri-plugins-workspace/plugins/haptics/ios/Sources/HapticsPlugin.swift:102-127
+///   makes a new generator and prepares it immediately before firing, which hides no latency.
+/// vibrate: react-native RCTVibration.mm:23-31 ignores the duration (kSystemSoundID_Vibrate is a fixed
+/// ~400 ms buzz). Tauri (HapticsPlugin.swift:64-100) plays a continuous CHHapticEvent of the duration,
+/// but creates an engine per call whose resetHandler captures it, so every call leaks one. Here one
+/// engine is kept, and the system sound is the fallback without Core Haptics hardware.
+/// Arguments arrive decoded and checked by the generated HapticsPluginSpec (PL-10).
+final class HapticsPlugin: HapticsPluginSpec {
+    static let id = "haptics"
+    private let context: AkanNativePluginContext
+    private var impacts: [HapticsImpactStyle: UIImpactFeedbackGenerator] = [:]
+    private var notifier: UINotificationFeedbackGenerator?
+    private var selector: UISelectionFeedbackGenerator?
+    private var engine: CHHapticEngine?
+    private var player: CHHapticPatternPlayer?
+
+    init(context: AkanNativePluginContext) {
+        self.context = context
+    }
+
+    func impact(_ args: HapticsImpactArgs, _ reply: AkanNativeReply<Void>) {
+        let name = args.style ?? .medium
+        guard let view = context.webView else { return reply.reject(.internalError, "no web view") }
+        let style: UIImpactFeedbackGenerator.FeedbackStyle = switch name {
+        case .light: .light
+        case .medium: .medium
+        case .heavy: .heavy
+        case .soft: .soft
+        case .rigid: .rigid
+        }
+        let generator = impacts[name] ?? Self.impactGenerator(style, view)
+        impacts[name] = generator
+        generator.impactOccurred()
+        generator.prepare()
+        reply.resolve()
+    }
+
+    func notification(_ args: HapticsNotificationArgs, _ reply: AkanNativeReply<Void>) {
+        guard let view = context.webView else { return reply.reject(.internalError, "no web view") }
+        let type: UINotificationFeedbackGenerator.FeedbackType = switch args.type ?? .success {
+        case .success: .success
+        case .warning: .warning
+        case .error: .error
+        }
+        let generator = notifier ?? Self.notificationGenerator(view)
+        notifier = generator
+        generator.notificationOccurred(type)
+        generator.prepare()
+        reply.resolve()
+    }
+
+    func selection(_ reply: AkanNativeReply<Void>) {
+        guard let view = context.webView else { return reply.reject(.internalError, "no web view") }
+        let generator = selector ?? Self.selectionGenerator(view)
+        selector = generator
+        generator.selectionChanged()
+        generator.prepare()
+        reply.resolve()
+    }
+
+    func vibrate(_ args: HapticsVibrateArgs, _ reply: AkanNativeReply<Void>) {
+        let value = args.duration ?? 300
+        guard value >= 1, value <= 10000 else {
+            return reply.reject(.invalidArgs, "duration must be a number of milliseconds between 1 and 10000")
+        }
+        let milliseconds = value.rounded()
+        if !CHHapticEngine.capabilitiesForHardware().supportsHaptics || !playContinuous(seconds: milliseconds / 1000) {
+            AudioServicesPlaySystemSound(kSystemSoundID_Vibrate) // fixed length; a no-op without a motor
+        }
+        reply.resolve()
+    }
+
+    private func playContinuous(seconds: Double) -> Bool {
+        do {
+            let engine = try self.engine ?? makeEngine()
+            try engine.start() // restarts it after auto shutdown, a reset or an interruption
+            let event = CHHapticEvent(
+                eventType: .hapticContinuous,
+                parameters: [
+                    CHHapticEventParameter(parameterID: .hapticIntensity, value: 1),
+                    CHHapticEventParameter(parameterID: .hapticSharpness, value: 1),
+                ],
+                relativeTime: 0,
+                duration: seconds
+            )
+            let next = try engine.makePlayer(with: CHHapticPattern(events: [event], parameters: []))
+            try? player?.stop(atTime: CHHapticTimeImmediate) // a new vibration replaces a running one
+            try next.start(atTime: CHHapticTimeImmediate)
+            player = next
+            return true
+        } catch {
+            engine = nil // recreated on the next call
+            player = nil
+            return false
+        }
+    }
+
+    private static func impactGenerator(_ style: UIImpactFeedbackGenerator.FeedbackStyle, _ view: UIView) -> UIImpactFeedbackGenerator {
+        if #available(iOS 17.5, *) { UIImpactFeedbackGenerator(style: style, view: view) } else { UIImpactFeedbackGenerator(style: style) }
+    }
+
+    private static func notificationGenerator(_ view: UIView) -> UINotificationFeedbackGenerator {
+        if #available(iOS 17.5, *) { UINotificationFeedbackGenerator(view: view) } else { UINotificationFeedbackGenerator() }
+    }
+
+    private static func selectionGenerator(_ view: UIView) -> UISelectionFeedbackGenerator {
+        if #available(iOS 17.5, *) { UISelectionFeedbackGenerator(view: view) } else { UISelectionFeedbackGenerator() }
+    }
+
+    private func makeEngine() throws -> CHHapticEngine {
+        let engine = try CHHapticEngine()
+        engine.playsHapticsOnly = true // no audio session needed
+        engine.isAutoShutdownEnabled = true // powers the hardware down while idle
+        self.engine = engine
+        return engine
+    }
+}

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

@@ -0,0 +1,19 @@
+{
+  "id": "haptics",
+  "apiVersion": 1,
+  "methods": ["impact", "notification", "selection", "vibrate"],
+  "events": [],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": null,
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "HapticsPlugin",
+    "frameworks": ["AudioToolbox", "CoreHaptics", "UIKit"]
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.haptics.HapticsPlugin",
+    "permissions": ["android.permission.VIBRATE"]
+  }
+}