@legendapp/spark 0.0.1-next.2 → 0.0.1-next.4

package/vendor/node_modules/@legendapp/spark-desktop-links/common/AuthLoopback.h

@@ -12,9 +12,8 @@
 #endif
 #include <atomic>
 #include <chrono>
-#include <mutex>
+#include <functional>
 #include <string>
-#include <vector>
 #include <thread>
 #include <stdexcept>
 #include <algorithm>
@@ -33,8 +32,7 @@ class AuthLoopback {
   AuthSocket listener = InvalidSocket;
   std::atomic<bool> stopped{false};
   std::thread worker;
-  std::mutex mutex;
-  std::vector<std::string> results;
+  std::function<void(std::string)> received;
   std::string route, origin;
   bool initialized = false;
   void Receive() {
@@ -71,15 +69,16 @@ class AuthLoopback {
             (request.substr(end, first - end) == " HTTP/1.1" || request.substr(end, first - end) == " HTTP/1.0");
         }
       }
-      if (valid) { std::lock_guard lock(mutex); if (results.size() < 16) results.push_back(origin + target); }
       const std::string body = valid ? "Callback received. You may return to the application." : "Invalid callback request.";
       const std::string response = std::string("HTTP/1.1 ") + (valid ? "200 OK" : "400 Bad Request") + "\r\nContent-Type: text/plain; charset=utf-8\r\nCache-Control: no-store\r\nConnection: close\r\nContent-Length: " + std::to_string(body.size()) + "\r\n\r\n" + body;
       send(client, response.data(), static_cast<int>(response.size()), 0); CloseSocket(client);
+      if (valid && !stopped) received(origin + target);
     }
     CloseSocket(listener); listener = InvalidSocket;
   }
  public:
-  AuthLoopback(unsigned short port, std::string path) : route(std::move(path)) {
+  AuthLoopback(unsigned short port, std::string path, std::function<void(std::string)> callback) : received(std::move(callback)), route(std::move(path)) {
+    if (!received) throw std::invalid_argument("Expected a callback listener");
     if (route.empty() || route[0] != '/' || route.find_first_not_of("/abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_") != std::string::npos) throw std::invalid_argument("Invalid callback path");
 #ifdef _WIN32
     WSADATA data{}; if (WSAStartup(MAKEWORD(2, 2), &data)) throw std::runtime_error("Could not initialize loopback socket"); initialized = true;
@@ -115,7 +114,6 @@ class AuthLoopback {
 #endif
   }
   std::string RedirectURI() const { return origin + route; }
-  std::vector<std::string> Drain() { std::lock_guard lock(mutex); auto values = std::move(results); results.clear(); return values; }
   AuthLoopback(AuthLoopback const &) = delete;
 };
 }

package/vendor/node_modules/@legendapp/spark-desktop-links/macos/RNDesktopLinks.mm

@@ -29,30 +29,31 @@ RCT_EXPORT_MODULE(NativeDesktopLinks)
         } else if ([method isEqual:@"authPrepare"]) {
           if (key.empty() || _authSessions.count(key) || _authSessions.size() >= 4) throw std::invalid_argument("Invalid or busy auth session");
           NSInteger port = [args[@"port"] integerValue]; if (port < 0 || port > 65535) throw std::invalid_argument("Invalid callback port");
-          auto receiver = std::make_unique<spark::AuthLoopback>((unsigned short)port, std::string([args[@"path"] UTF8String]));
+          auto receiver = std::make_unique<spark::AuthLoopback>((unsigned short)port, std::string([args[@"path"] UTF8String]), [identifier](std::string value) {
+            NSString *url = [NSString stringWithUTF8String:value.c_str()];
+            dispatch_async(dispatch_get_main_queue(), ^{ SparkEmit(@{ @"type": @"authRedirect", @"id": identifier, @"url": url }); });
+          });
           NSString *uri = [NSString stringWithUTF8String:receiver->RedirectURI().c_str()]; _authSessions.emplace(key, std::move(receiver)); resolve(SparkJSON(uri));
         } else if ([method isEqual:@"authClose"]) { _authSessions.erase(key); resolve(@"null"); }
-        else if ([method isEqual:@"authPoll"]) {
-          auto found = _authSessions.find(key); if (found == _authSessions.end()) throw std::invalid_argument("Auth session is closed");
-          NSMutableArray *urls = [NSMutableArray new]; for (auto const &value : found->second->Drain()) [urls addObject:[NSString stringWithUTF8String:value.c_str()]];
-          resolve(SparkJSON(urls));
-        } else throw std::invalid_argument("Unknown auth operation");
+        else throw std::invalid_argument("Unknown auth operation");
       } catch (std::exception const &error) { reject(@"E_AUTH", [NSString stringWithUTF8String:error.what()], nil); }
       return;
     }
     if ([method isEqual:@"recent"]) {
       NSArray *result = [NSUserDefaults.standardUserDefaults arrayForKey:[SparkNamespace() stringByAppendingString:@".recentDocuments"]] ?: @[];
-      resolve(SparkJSON(result)); return;
+      NSMutableArray *paths = [NSMutableArray new];
+      for (NSString *value in result) { NSURL *url = [NSURL URLWithString:value]; if (!url.isFileURL || !url.path.length) { reject(@"E_INVALID_DATA", @"Invalid recent document URL", nil); return; } [paths addObject:url.path]; }
+      resolve(SparkJSON(paths)); return;
     }
     if ([method isEqual:@"clearRecent"]) {
       [NSUserDefaults.standardUserDefaults removeObjectForKey:[SparkNamespace() stringByAppendingString:@".recentDocuments"]];
       if (![SparkContext()[@"runtime"][@"mode"] isEqual:@"go"]) [NSDocumentController.sharedDocumentController clearRecentDocuments:nil];
       resolve(@"null"); return;
     }
-    NSURL *url = [NSURL URLWithString:args[@"url"] ?: @""];
+    NSURL *url = ([method isEqual:@"noteRecent"] || [method isEqual:@"openPath"]) ? [NSURL fileURLWithPath:args[@"path"]] : [NSURL URLWithString:args[@"url"] ?: @""];
     if (!url.scheme.length) { SparkInvalid(reject, @"URL must have a scheme"); return; }
     if ([method isEqual:@"canOpen"]) resolve(SparkJSON(@([NSWorkspace.sharedWorkspace URLForApplicationToOpenURL:url] != nil)));
-    else if ([method isEqual:@"open"]) {
+    else if ([method isEqual:@"open"] || [method isEqual:@"openPath"]) {
       // Opening a URL can deliver an Apple event back to this app. Keep its
       // main run loop free while LaunchServices resolves and opens the target.
       [NSWorkspace.sharedWorkspace openURL:url configuration:NSWorkspaceOpenConfiguration.configuration

package/vendor/node_modules/@legendapp/spark-desktop-links/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-desktop-links",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.4",
   "license": "MIT",
   "main": "src/index",
   "react-native": "src/index",
@@ -42,7 +42,7 @@
     ]
   },
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+    "@legendapp/spark-desktop-app": "0.0.1-next.4"
   },
   "peerDependenciesMeta": {
     "expo-linking": {

package/vendor/node_modules/@legendapp/spark-desktop-links/src/NativeDesktopLinks.ts

@@ -3,4 +3,4 @@ import { TurboModuleRegistry } from "react-native";
 export interface Spec extends TurboModule {
   call(method: string, args: string): Promise<string>;
 }
-export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopLinks");
+export default TurboModuleRegistry.get<Spec>("NativeDesktopLinks");

package/vendor/node_modules/@legendapp/spark-desktop-links/src/api.ts

@@ -1,37 +1,31 @@
-import Native from "./NativeDesktopLinks";
-import { callApp, onDesktopEvent, type DesktopEvent } from "@legendapp/spark-desktop-app";
-export type OpenEvent = { type: "openFile" | "openURL"; id: string; url: string };
-function url(value: string) { if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value)) throw new Error("URL must include a scheme"); return value; }
-async function call<T = void>(method: string, args: object = {}): Promise<T> { return JSON.parse(await Native.call(method, JSON.stringify(args))) as T; }
-export async function openURL(value: string): Promise<true> {
-  await call("open", { url: url(value) }); return true;
+import { Platform } from "react-native";
+import { onDesktopEvent } from "@legendapp/spark-desktop-app/src/events";
+import { callAppNative } from "@legendapp/spark-desktop-app/src/transport";
+import { nativePath } from "@legendapp/spark-desktop-app/src/contracts/path";
+import { SparkError, type Subscription } from "@legendapp/spark-desktop-app/src/contracts";
+export type { Subscription } from "@legendapp/spark-desktop-app/src/contracts";
+import { callLinks, linksCommand } from "./native";
+export type URLListener = (event: { url: string }) => void;
+function url(value: string) {
+  if (typeof value !== "string" || !/^[a-z][a-z0-9+.-]*:/i.test(value) || value.includes("\0")) throw new SparkError("E_INVALID_ARGUMENT", "URL must include a scheme and contain no NUL");
+  return value;
 }
-export async function canOpenURL(value: string): Promise<boolean> { return call("canOpen", { url: url(value) }); }
-export const noteRecentDocument = (value: string) => call("noteRecent", { url: url(value) });
-export const clearRecentDocuments = () => call("clearRecent");
-export const getRecentDocuments = () => call<string[]>("recent");
-/** Subscribe before fetching queued launches; event ids deduplicate the overlap. */
-export async function onOpen(listener: (event: OpenEvent) => void) {
-  const seen = new Set<string>(); let removed = false;
-  function deliver(event: DesktopEvent) {
-    if (removed || (event.type !== "openFile" && event.type !== "openURL") || !event.id || seen.has(event.id)) return;
-    seen.add(event.id);
-    if (seen.size > 200) seen.delete(seen.values().next().value!);
-    listener(event as OpenEvent);
-  }
-  const subscription = onDesktopEvent(deliver);
-  try { for (const event of await callApp<DesktopEvent[]>("pendingURLs")) deliver(event); }
-  catch (error) { subscription.remove(); throw error; }
-  return { remove() { removed = true; subscription.remove(); } };
+/** Selected Expo Linking contract: resolves true after native launch acceptance. */
+export async function openURL(value: string): Promise<true> { await linksCommand("open", { url: url(value) }); return true; }
+export function canOpenURL(value: string): Promise<boolean> {
+  return Promise.resolve().then(() => callLinks("canOpen", { url: url(value) }, (value): value is boolean => typeof value === "boolean"));
 }
-
-export type URLListener = (event: { url: string }) => void;
-/** URL that launched this native process, or null; stable across later opens and JS reloads. */
-export const getInitialURL = (): Promise<string | null> => callApp("initialURL");
-/** Live URL events only. Use onOpen for queued desktop URLs and file-open events. */
-export function addEventListener(type: "url", listener: URLListener): { remove(): void } {
-  if (type !== "url" || typeof listener !== "function") throw new TypeError("Expected a url event listener");
+/** Spark extension: open a local file or directory in its associated application. */
+export async function openPath(path: string): Promise<void> { await linksCommand("openPath", { path: nativePath(path, Platform.OS) }); }
+/** Stable native-process launch URL; later opens and JS reloads do not replace it. */
+export function getInitialURL(): Promise<string | null> {
+  return callAppNative("initialURL", (value): value is string | null => value === null || (typeof value === "string" && /^[a-z][a-z0-9+.-]*:/i.test(value) && !value.includes("\0")));
+}
+/** Live URL events only. Queued file/URL requests belong to app/documents. */
+export function addEventListener(type: "url", listener: URLListener): Subscription {
+  if (type !== "url" || typeof listener !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected a url event listener");
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") throw new SparkError("E_UNSUPPORTED_PLATFORM", "Desktop URL events require a desktop host");
   return onDesktopEvent(event => {
-    if (event.type === "openURL" && event.initial !== true && typeof event.url === "string") listener({ url: event.url });
-  });
+    if (event.type === "openURL" && event.initial !== true && typeof event.url === "string" && /^[a-z][a-z0-9+.-]*:/i.test(event.url) && !event.url.includes("\0")) listener({ url: event.url });
+  }, { types: ["openURL"] });
 }

package/vendor/node_modules/@legendapp/spark-desktop-links/src/expo.ts

@@ -1,5 +1,4 @@
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
 export { openURL, canOpenURL, getInitialURL, addEventListener } from "expo-linking";
-export type { OpenEvent, URLListener } from "./index";
-/** Legacy desktop facilities have no shared equivalent. */
-const unavailable = async (..._args: unknown[]): Promise<never> => { throw Object.assign(new Error("Desktop document events/history are unavailable on this platform; use URL events instead"), { code: "E_UNAVAILABLE" }); };
-export const onOpen = unavailable, noteRecentDocument = unavailable, clearRecentDocuments = unavailable, getRecentDocuments = unavailable;
+export type { URLListener } from "./api";
+export async function openPath(_path: string): Promise<void> { throw new SparkError("E_UNSUPPORTED_PLATFORM", "Opening a native desktop path requires a desktop host"); }

package/vendor/node_modules/@legendapp/spark-desktop-links/src/native.ts

@@ -0,0 +1,9 @@
+import { Platform } from "react-native";
+import Native from "./NativeDesktopLinks";
+import { SparkError, invokeNative, parseNativeResult } from "@legendapp/spark-desktop-app/src/contracts";
+export async function callLinks<T>(method: string, args: object, validate: (value: unknown) => value is T): Promise<T> {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") throw new SparkError("E_UNSUPPORTED_PLATFORM", "Desktop linking requires a desktop host");
+  if (!Native) throw new SparkError("E_MODULE_UNAVAILABLE", "Desktop linking module is unavailable");
+  return parseNativeResult(await invokeNative(() => Native!.call(method, JSON.stringify(args))), validate);
+}
+export async function linksCommand(method: string, args: object = {}): Promise<void> { await callLinks(method, args, (value): value is null => value === null); }

package/vendor/node_modules/@legendapp/spark-desktop-links/windows/SparkLinks/SparkLinks.h

@@ -41,13 +41,17 @@ struct RecentDocuments {
   }
   void Write(Json::JsonArray const &list) { auto value = list.Stringify(); check_win32(RegSetValueExW(key, L"URLs", 0, REG_SZ, reinterpret_cast<BYTE const *>(value.c_str()), static_cast<DWORD>((value.size() + 1) * sizeof(wchar_t)))); }
   bool ShellEnabled() { wchar_t mode[16]{}; GetEnvironmentVariableW(L"SPARK_RUNTIME_MODE", mode, 16); return std::wstring(mode) == L"dev"; }
-  void Add(hstring const &url) {
+  static std::wstring Path(hstring const &url) {
+    DWORD size = 32768; std::wstring path(size, L'\0'); check_hresult(PathCreateFromUrlW(url.c_str(), path.data(), &size, 0)); path.resize(wcslen(path.c_str())); return path;
+  }
+  Json::JsonArray Paths() { Json::JsonArray paths; for (auto const &entry : Read()) paths.Append(Json::JsonValue::CreateStringValue(Path(entry.GetString()))); return paths; }
+  void Add(hstring const &path) {
+    DWORD size = 32768; std::wstring url(size, L'\0'); check_hresult(UrlCreateFromPathW(path.c_str(), url.data(), &size, 0)); url.resize(wcslen(url.c_str()));
     Windows::Foundation::Uri uri(url);
     if (uri.SchemeName() != L"file") throw hresult_invalid_argument(L"Recent documents require file URLs");
     Json::JsonArray next; next.Append(Json::JsonValue::CreateStringValue(uri.AbsoluteUri()));
     for (auto const &entry : Read()) if (entry.GetString() != uri.AbsoluteUri() && next.Size() < 20) next.Append(entry);
     if (ShellEnabled()) {
-      DWORD size = 32768; std::wstring path(size, L'\0'); check_hresult(PathCreateFromUrlW(uri.AbsoluteUri().c_str(), path.data(), &size, 0));
       com_ptr<IShellItem> item; check_hresult(SHCreateItemFromParsingName(path.c_str(), nullptr, IID_PPV_ARGS(item.put())));
       SHARDAPPIDINFO info{item.get(), appId.c_str()}; SHAddToRecentDocs(SHARD_APPIDINFO, &info);
     }
@@ -68,7 +72,7 @@ struct SparkLinks {
   React::ReactContext context;
   REACT_INIT(Initialize)
   void Initialize(React::ReactContext const &value) noexcept { context = value; }
-  static fire_and_forget Invoke(std::shared_ptr<Receivers> receivers, std::string method, std::string encoded, React::ReactPromise<std::string> promise) {
+  static fire_and_forget Invoke(React::ReactContext context, std::shared_ptr<Receivers> receivers, std::string method, std::string encoded, React::ReactPromise<std::string> promise) {
     try {
       auto args = Json::JsonObject::Parse(to_hstring(encoded));
       if (method == "cryptoRandom") {
@@ -86,32 +90,28 @@ struct SparkLinks {
         if (method == "authPrepare") {
           if (id.empty() || receivers->count(id) || receivers->size() >= 4) throw hresult_invalid_argument(L"Invalid or busy auth session");
           auto port = args.GetNamedNumber(L"port"); if (port < 0 || port > 65535 || port != std::floor(port)) throw hresult_invalid_argument(L"Invalid callback port");
-          auto receiver = std::make_unique<spark::AuthLoopback>(static_cast<unsigned short>(port), to_string(args.GetNamedString(L"path")));
+          auto receiver = std::make_unique<spark::AuthLoopback>(static_cast<unsigned short>(port), to_string(args.GetNamedString(L"path")), [context, id](std::string url) {
+            context.UIDispatcher().Post([context, id, url = std::move(url)] {
+              context.EmitJSEvent(L"RCTDeviceEventEmitter", L"desktop", React::JSValueObject{{"type", "authRedirect"}, {"id", id}, {"url", url}});
+            });
+          });
           auto uri = receiver->RedirectURI(); receivers->emplace(id, std::move(receiver)); promise.Resolve(to_string(Json::JsonValue::CreateStringValue(to_hstring(uri)).Stringify()));
         } else if (method == "authClose") { receivers->erase(id); promise.Resolve("null"); }
-        else if (method == "authPoll") {
-          auto found = receivers->find(id); if (found == receivers->end()) throw hresult_invalid_argument(L"Auth session is closed");
-          Json::JsonArray urls; for (auto const &uri : found->second->Drain()) urls.Append(Json::JsonValue::CreateStringValue(to_hstring(uri))); promise.Resolve(to_string(urls.Stringify()));
-        } else throw hresult_invalid_argument(L"Unknown auth operation");
+        else throw hresult_invalid_argument(L"Unknown auth operation");
       } else if (method == "recent" || method == "noteRecent" || method == "clearRecent") {
         RecentDocuments recent;
-        if (method == "recent") promise.Resolve(to_string(recent.Read().Stringify()));
-        else { if (method == "noteRecent") recent.Add(args.GetNamedString(L"url")); else recent.Clear(); promise.Resolve("null"); }
-      } else if (method == "initialURL") {
-        int count = 0; auto arguments = CommandLineToArgvW(GetCommandLineW(), &count); hstring initial;
-        if (arguments) {
-          for (int i = 1; i < count; ++i) {
-            std::wstring candidate(arguments[i]); const auto colon = candidate.find(L':');
-            if (colon != std::wstring::npos && colon > 1 && candidate[0] != L'-') { initial = candidate; break; }
-          }
-          LocalFree(arguments);
-        }
-        promise.Resolve(initial.empty() ? "null" : to_string(Json::JsonValue::CreateStringValue(initial).Stringify()));
+        if (method == "recent") promise.Resolve(to_string(recent.Paths().Stringify()));
+        else { if (method == "noteRecent") recent.Add(args.GetNamedString(L"path")); else recent.Clear(); promise.Resolve("null"); }
+      } else if (method == "openPath") {
+        auto path = args.GetNamedString(L"path");
+        auto result = reinterpret_cast<INT_PTR>(ShellExecuteW(nullptr, L"open", path.c_str(), nullptr, nullptr, SW_SHOWNORMAL));
+        if (result <= 32) { promise.Reject(React::ReactError{result == SE_ERR_FNF || result == SE_ERR_PNF ? "E_NOT_FOUND" : result == SE_ERR_ACCESSDENIED ? "E_PERMISSION_DENIED" : "E_NATIVE", "No application opened this path"}); co_return; }
+        promise.Resolve("null");
       } else {
         Windows::Foundation::Uri uri(args.GetNamedString(L"url"));
         if (method == "open") {
           if (!co_await Windows::System::Launcher::LaunchUriAsync(uri)) { promise.Reject(React::ReactError{"E_OPEN_URL", "No application opened this URL"}); co_return; }
-          promise.Resolve("true");
+          promise.Resolve("null");
         } else if (method == "canOpen") {
           auto status = co_await Windows::System::Launcher::QueryUriSupportAsync(uri, Windows::System::LaunchQuerySupportType::Uri);
           promise.Resolve(status == Windows::System::LaunchQuerySupportStatus::Available ? "true" : "false");
@@ -122,7 +122,7 @@ struct SparkLinks {
   }
   REACT_METHOD(call)
   void call(std::string method, std::string args, React::ReactPromise<std::string> promise) noexcept {
-    context.UIDispatcher().Post([receivers = receivers, method = std::move(method), args = std::move(args), promise]() { Invoke(receivers, method, args, promise); });
+    context.UIDispatcher().Post([context = context, receivers = receivers, method = std::move(method), args = std::move(args), promise]() { Invoke(context, receivers, method, args, promise); });
   }
 };
 }

package/vendor/node_modules/@legendapp/spark-desktop-shortcuts/RNDesktopShortcuts.podspec

@@ -13,4 +13,5 @@ Pod::Spec.new do |s|
   s.dependency "React-Core"
   s.dependency "ReactCodegen"
   s.dependency "RNDesktopApp"
+  s.osx.frameworks = "AppKit", "Carbon"
 end

package/vendor/node_modules/@legendapp/spark-desktop-shortcuts/macos/RNDesktopShortcuts.mm

@@ -16,7 +16,7 @@ RCT_EXPORT_MODULE(NativeDesktopShortcuts)
       for (NSDictionary *existing in self.shortcuts.allValues) {
         if ([existing[@"key"] isEqual:args[@"key"]] && [existing[@"modifiers"] isEqual:args[@"modifiers"]] &&
           ((!existing[@"windowId"] && !args[@"windowId"]) || [existing[@"windowId"] isEqual:args[@"windowId"]])) {
-          reject(@"E_SHORTCUT_CONFLICT", @"Shortcut is already registered in this scope", nil); return;
+          reject(@"E_BUSY", @"Shortcut is already registered in this scope", nil); return;
         }
       }
       self.shortcuts[args[@"id"]] = args;

package/vendor/node_modules/@legendapp/spark-desktop-shortcuts/macos/keyboard-manager/RNKeyboardManager.h

@@ -0,0 +1,9 @@
+#import <React/RCTEventEmitter.h>
+#import <RNDesktopShortcutsSpec/RNDesktopShortcutsSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNKeyboardManager : RCTEventEmitter <NativeKeyboardManagerSpec>
+@end
+
+NS_ASSUME_NONNULL_END

package/vendor/node_modules/@legendapp/spark-desktop-shortcuts/macos/keyboard-manager/RNKeyboardManager.mm

@@ -0,0 +1,307 @@
+#import "RNKeyboardManager.h"
+
+#import <React/RCTBridgeModule.h>
+#import <TargetConditionals.h>
+#include <cmath>
+#include <atomic>
+
+#if TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+#import <IOKit/hidsystem/IOLLEvent.h>
+#import <IOKit/hidsystem/ev_keymap.h>
+#endif
+
+static NSInteger const RNKeyboardMediaPlayPause = 10001;
+static NSInteger const RNKeyboardMediaNext = 10002;
+static NSInteger const RNKeyboardMediaPrevious = 10003;
+
+#if TARGET_OS_OSX
+static NSUInteger const RNKeyboardModifierMask = NSEventModifierFlagCommand | NSEventModifierFlagControl | NSEventModifierFlagOption | NSEventModifierFlagShift | NSEventModifierFlagFunction | NSEventModifierFlagCapsLock;
+@interface SparkKeyboardRule : NSObject
+@property (nonatomic, copy) NSString *key;
+@property (nonatomic) NSUInteger modifiers;
+@property (nonatomic) BOOL allowExtraModifiers;
+@property (nonatomic) BOOL repeat;
+@property (nonatomic, copy) NSSet<NSString *> *windowIds;
+@property (nonatomic, copy) NSSet<NSString *> *excludedWindowIds;
+@end
+@implementation SparkKeyboardRule @end
+
+static BOOL SparkKeyboardBoolean(id value) { return [value isKindOfClass:NSNumber.class] && CFGetTypeID((__bridge CFTypeRef)value) == CFBooleanGetTypeID(); }
+
+// Stripping modifiers renders navigation and function keys as C0 control characters (Right is
+// U+001D, Backspace U+0008), which no accelerator can name; accelerators parse AppKit's
+// private-use code and U+007F instead. Tab and Return are also C0 but already spell their
+// accelerators, so only keys whose unmodified character identifies them are substituted.
+static NSString *SparkKeyboardKeyString(NSEvent *event) {
+  NSString *key = [event charactersByApplyingModifiers:0] ?: @"";
+  if (key.length == 1 && [key characterAtIndex:0] < 0x20) {
+    NSString *unmodified = event.charactersIgnoringModifiers;
+    if (unmodified.length == 1) {
+      unichar code = [unmodified characterAtIndex:0];
+      if ((code >= 0xF700 && code <= 0xF747) || code == 0x7F) return unmodified.lowercaseString;
+    }
+  }
+  return key.lowercaseString;
+}
+static NSSet<NSString *> *SparkKeyboardWindows(id value, BOOL *valid) {
+  if (!value) return nil;
+  if (![value isKindOfClass:NSArray.class]) { *valid = NO; return nil; }
+  for (id identifier in value) if (![identifier isKindOfClass:NSString.class] || ![identifier length]) { *valid = NO; return nil; }
+  return [NSSet setWithArray:value];
+}
+#endif
+
+@implementation RNKeyboardManager {
+  std::atomic<bool> _hasListeners;
+#if TARGET_OS_OSX
+  id _localEventMonitor;
+  NSMutableDictionary<NSString *, NSArray<SparkKeyboardRule *> *> *_consumptionOwners;
+  NSMutableSet<NSString *> *_captureOwners;
+  NSDictionary<NSString *, NSArray<SparkKeyboardRule *> *> *_rulesByKey;
+  NSMutableDictionary<NSNumber *, NSNumber *> *_consumedKeys;
+#endif
+}
+
+RCT_EXPORT_MODULE(NativeKeyboardManager)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _hasListeners.store(false, std::memory_order_relaxed);
+#if TARGET_OS_OSX
+    _consumptionOwners = [NSMutableDictionary new];
+    _captureOwners = [NSMutableSet new];
+    _rulesByKey = @{};
+    _consumedKeys = [NSMutableDictionary new];
+    [NSNotificationCenter.defaultCenter addObserver:self
+                                           selector:@selector(applicationWillTerminate:)
+                                               name:NSApplicationWillTerminateNotification
+                                             object:nil];
+#endif
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+#if TARGET_OS_OSX
+  id monitor = _localEventMonitor;
+  if (monitor) {
+    if (NSThread.isMainThread) [NSEvent removeMonitor:monitor];
+    else dispatch_async(dispatch_get_main_queue(), ^{ [NSEvent removeMonitor:monitor]; });
+  }
+  [NSNotificationCenter.defaultCenter removeObserver:self];
+#endif
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"onKeyDown", @"onKeyUp"];
+}
+
+- (void)startObserving
+{
+  _hasListeners.store(true, std::memory_order_relaxed);
+}
+
+- (void)stopObserving
+{
+  _hasListeners.store(false, std::memory_order_relaxed);
+#if TARGET_OS_OSX
+  if (NSThread.isMainThread) [self stopMonitoringInternal];
+  else dispatch_async(dispatch_get_main_queue(), ^{ [self stopMonitoringInternal]; });
+#endif
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeKeyboardManagerSpecJSI>(params);
+}
+
+- (void)startMonitoringKeyboard:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+#if TARGET_OS_OSX
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self startMonitoringInternal];
+    if (self->_localEventMonitor) resolve(@YES); else reject(@"E_UNAVAILABLE", @"Keyboard event monitor could not start", nil);
+  });
+#else
+  reject(@"E_UNSUPPORTED_PLATFORM", @"Keyboard monitoring requires macOS", nil);
+#endif
+}
+
+- (void)stopMonitoringKeyboard:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+#if TARGET_OS_OSX
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self stopMonitoringInternal];
+    resolve(@YES);
+  });
+#else
+  resolve(@NO);
+#endif
+}
+
+- (void)setConsumption:(NSString *)ownerId rulesJson:(NSString *)rulesJson capture:(BOOL)capture resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+#if TARGET_OS_OSX
+  id values = [NSJSONSerialization JSONObjectWithData:[rulesJson dataUsingEncoding:NSUTF8StringEncoding] options:NSJSONReadingFragmentsAllowed error:nil];
+  if (!ownerId.length || ![values isKindOfClass:NSArray.class]) { reject(@"E_INVALID_ARGUMENT", @"Expected an owner and keyboard consumption rules", nil); return; }
+  NSMutableArray<SparkKeyboardRule *> *rules = [NSMutableArray new];
+  for (id value in values) {
+    if (![value isKindOfClass:NSDictionary.class]) { reject(@"E_INVALID_ARGUMENT", @"Invalid keyboard consumption rule", nil); return; }
+    id key = value[@"key"], modifiers = value[@"modifiers"];
+    BOOL valid = [key isKindOfClass:NSString.class] && [key length] && [modifiers isKindOfClass:NSNumber.class] && !SparkKeyboardBoolean(modifiers);
+    double bits = valid ? [modifiers doubleValue] : -1;
+    valid = valid && std::isfinite(bits) && bits >= 0 && bits <= RNKeyboardModifierMask && std::floor(bits) == bits && (((NSUInteger)bits & ~RNKeyboardModifierMask) == 0);
+    valid = valid && SparkKeyboardBoolean(value[@"allowExtraModifiers"]) && SparkKeyboardBoolean(value[@"repeat"]);
+    SparkKeyboardRule *rule = [SparkKeyboardRule new];
+    rule.windowIds = SparkKeyboardWindows(value[@"windowIds"], &valid);
+    rule.excludedWindowIds = SparkKeyboardWindows(value[@"excludedWindowIds"], &valid);
+    if (!valid) { reject(@"E_INVALID_ARGUMENT", @"Invalid keyboard consumption rule", nil); return; }
+    rule.key = [key lowercaseString]; rule.modifiers = (NSUInteger)bits;
+    rule.allowExtraModifiers = [value[@"allowExtraModifiers"] boolValue]; rule.repeat = [value[@"repeat"] boolValue];
+    [rules addObject:rule];
+  }
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (rules.count) self->_consumptionOwners[ownerId] = rules; else [self->_consumptionOwners removeObjectForKey:ownerId];
+    if (capture) [self->_captureOwners addObject:ownerId]; else [self->_captureOwners removeObject:ownerId];
+    NSMutableDictionary<NSString *, NSMutableArray<SparkKeyboardRule *> *> *byKey = [NSMutableDictionary new];
+    for (NSArray<SparkKeyboardRule *> *ownerRules in self->_consumptionOwners.allValues) for (SparkKeyboardRule *rule in ownerRules) {
+      if (!byKey[rule.key]) byKey[rule.key] = [NSMutableArray new];
+      [byKey[rule.key] addObject:rule];
+    }
+    self->_rulesByKey = byKey;
+    resolve(@YES);
+  });
+#else
+  reject(@"E_UNSUPPORTED_PLATFORM", @"Keyboard consumption requires macOS", nil);
+#endif
+}
+
+- (void)invalidate
+{
+  _hasListeners.store(false, std::memory_order_relaxed);
+#if TARGET_OS_OSX
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self stopMonitoringInternal];
+    [self->_consumptionOwners removeAllObjects]; [self->_captureOwners removeAllObjects]; self->_rulesByKey = @{};
+  });
+#endif
+  [super invalidate];
+}
+
+#if TARGET_OS_OSX
+- (void)applicationWillTerminate:(NSNotification *)notification
+{
+  [self stopMonitoringInternal];
+}
+
+- (void)startMonitoringInternal
+{
+  [self stopMonitoringInternal];
+  __weak RNKeyboardManager *weakSelf = self;
+  NSEventMask eventMask = NSEventMaskKeyDown | NSEventMaskKeyUp | NSEventMaskSystemDefined;
+  _localEventMonitor = [NSEvent addLocalMonitorForEventsMatchingMask:eventMask handler:^NSEvent *(NSEvent *event) {
+    RNKeyboardManager *strongSelf = weakSelf;
+    if (!strongSelf) {
+      return event;
+    }
+    return [strongSelf handleKeyboardEvent:event];
+  }];
+}
+
+- (void)stopMonitoringInternal
+{
+  if (_localEventMonitor) {
+    [NSEvent removeMonitor:_localEventMonitor];
+    _localEventMonitor = nil;
+  }
+  [_consumedKeys removeAllObjects];
+}
+
+- (NSEvent *)handleKeyboardEvent:(NSEvent *)event
+{
+  if (event.type == NSEventTypeSystemDefined) {
+    return [self handleSystemDefinedEvent:event];
+  }
+
+  if (event.type != NSEventTypeKeyDown && event.type != NSEventTypeKeyUp) {
+    return event;
+  }
+
+  NSString *eventName = event.type == NSEventTypeKeyDown ? @"onKeyDown" : @"onKeyUp";
+  BOOL handled = [self emitKeyboardEvent:eventName keyCode:event.keyCode key:SparkKeyboardKeyString(event) modifiers:event.modifierFlags window:event.window repeated:event.isARepeat];
+  return handled ? nil : event;
+}
+
+- (NSEvent *)handleSystemDefinedEvent:(NSEvent *)event
+{
+  if (event.subtype != NX_SUBTYPE_AUX_CONTROL_BUTTONS) {
+    return event;
+  }
+  NSInteger data = event.data1;
+  NSInteger keyCode = (data & 0xFFFF0000) >> 16;
+  NSInteger keyFlags = data & 0x0000FFFF;
+  NSInteger keyState = (keyFlags & 0xFF00) >> 8;
+  NSNumber *mappedKeyCode = [self mappedMediaKeyCode:keyCode];
+  if (!mappedKeyCode) {
+    return event;
+  }
+  NSString *eventName = keyState == NX_KEYDOWN ? @"onKeyDown" : @"onKeyUp";
+  BOOL handled = [self emitKeyboardEvent:eventName keyCode:mappedKeyCode.integerValue key:@{@10001: @"MediaPlayPause", @10002: @"MediaNext", @10003: @"MediaPrevious"}[mappedKeyCode] modifiers:event.modifierFlags window:event.window repeated:(keyFlags & 1) != 0];
+  return handled ? nil : event;
+}
+
+- (NSNumber *)mappedMediaKeyCode:(NSInteger)keyCode
+{
+  switch (keyCode) {
+    case NX_KEYTYPE_PLAY:
+      return @(RNKeyboardMediaPlayPause);
+    case NX_KEYTYPE_FAST:
+    case NX_KEYTYPE_NEXT:
+      return @(RNKeyboardMediaNext);
+    case NX_KEYTYPE_REWIND:
+    case NX_KEYTYPE_PREVIOUS:
+      return @(RNKeyboardMediaPrevious);
+    default:
+      return nil;
+  }
+}
+
+- (BOOL)emitKeyboardEvent:(NSString *)eventName keyCode:(NSInteger)keyCode key:(NSString *)key modifiers:(NSUInteger)modifiers window:(NSWindow *)window repeated:(BOOL)repeated
+{
+  NSString *identifier = (window ?: NSApp.keyWindow).identifier;
+  NSString *windowId = [identifier hasPrefix:@"spark."] ? [identifier substringFromIndex:6] : identifier;
+  BOOL down = [eventName isEqual:@"onKeyDown"];
+  NSNumber *held = _consumedKeys[@(keyCode)];
+  BOOL captured = _captureOwners.count > 0 || (!down && held.boolValue);
+  BOOL consumed = captured || (!down && held != nil);
+  if (down && !consumed) {
+    NSString *normalizedKey = key.lowercaseString;
+    for (SparkKeyboardRule *rule in _rulesByKey[normalizedKey]) {
+      if ((repeated && !rule.repeat) || (rule.windowIds && (!windowId || ![rule.windowIds containsObject:windowId])) || (windowId && [rule.excludedWindowIds containsObject:windowId])) continue;
+      NSUInteger active = modifiers & RNKeyboardModifierMask;
+      if (!(rule.modifiers & NSEventModifierFlagCapsLock)) active &= ~NSEventModifierFlagCapsLock;
+      if (!(rule.modifiers & NSEventModifierFlagFunction) && key.length == 1 && [key characterAtIndex:0] >= 0xf700 && [key characterAtIndex:0] <= 0xf747) active &= ~NSEventModifierFlagFunction;
+      if (rule.allowExtraModifiers ? (active & rule.modifiers) == rule.modifiers : active == rule.modifiers) { consumed = YES; break; }
+    }
+  }
+  if (down && consumed) _consumedKeys[@(keyCode)] = @(captured || held.boolValue);
+  if (!down) [_consumedKeys removeObjectForKey:@(keyCode)];
+  if (_hasListeners.load(std::memory_order_relaxed)) [self sendEventWithName:eventName body:@{
+    @"keyCode": @(keyCode), @"key": key, @"modifiers": @(modifiers), @"windowId": windowId ?: (id)NSNull.null,
+    @"repeated": @(repeated), @"consumed": @(consumed), @"captured": @(captured),
+  }];
+  return consumed;
+}
+#endif
+
+@end