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

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

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-desktop-shortcuts",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.4",
   "license": "MIT",
   "main": "src/index",
   "react-native": "src/index",
@@ -19,14 +19,17 @@
     "jsSrcsDir": "src",
     "ios": {
       "modulesProvider": {
-        "NativeDesktopShortcuts": "RNDesktopShortcuts"
-      }
+        "NativeDesktopShortcuts": "RNDesktopShortcuts",
+        "NativeKeyboardManager": "RNKeyboardManager"
+      },
+      "componentProvider": {}
     }
   },
   "spark": {
     "sdk": true,
     "nativeModules": [
-      "NativeDesktopShortcuts"
+      "NativeDesktopShortcuts",
+      "NativeKeyboardManager"
     ],
     "pod": "RNDesktopShortcuts",
     "platforms": [
@@ -37,7 +40,7 @@
     ]
   },
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+    "@legendapp/spark-desktop-app": "0.0.1-next.4"
   },
   "private": true
 }

package/vendor/node_modules/@legendapp/spark-desktop-shortcuts/src/NativeDesktopShortcuts.ts

@@ -5,4 +5,4 @@ export interface Spec extends TurboModule {
   addListener(eventName: string): void;
   removeListeners(count: number): void;
 }
-export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopShortcuts");
+export default TurboModuleRegistry.get<Spec>("NativeDesktopShortcuts");

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

@@ -1,20 +1,45 @@
 import { NativeEventEmitter, Platform } from "react-native";
 import Native from "./NativeDesktopShortcuts";
-import { parseAccelerator } from "./accelerator";
-export { parseAccelerator } from "./accelerator";
-const emitter = new NativeEventEmitter(Native);
-export type ShortcutOptions = { windowId?: string; repeat?: boolean };
-/** Focused-app shortcuts, consumed natively before insertion into text fields. */
-export async function registerShortcut(accelerator: string, handler: () => void, options: ShortcutOptions = {}) {
+import { parseAccelerator } from "@legendapp/spark-desktop-app/src/contracts/accelerator";
+import { SparkError, invokeNative, parseNativeResult, asyncRegistration, type AsyncRegistration, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+export type { AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+export { parseAccelerator, type Accelerator } from "@legendapp/spark-desktop-app/src/contracts/accelerator";
+export interface ShortcutOptions { windowId?: string; repeat?: boolean }
+export function getShortcutAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return Native ? { available: true } : { available: false, reason: "missing-module" };
+}
+function native() {
+  const availability = getShortcutAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "Application shortcuts are unavailable");
+  return Native!;
+}
+async function call(method: string, args: object) {
+  parseNativeResult(await invokeNative(() => native().call(method, JSON.stringify(args))), (value): value is null => value === null);
+}
+/** Focused-app shortcuts, consumed before insertion into text fields. Repeat defaults to false. */
+export async function registerShortcut(accelerator: string, handler: () => void, options: ShortcutOptions = {}): Promise<AsyncRegistration> {
+  if (typeof handler !== "function" || !options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected shortcut handler and options");
+  for (const key of Object.keys(options)) if (!["windowId", "repeat"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unsupported shortcut option: ${key}`);
+  if (options.windowId !== undefined && (typeof options.windowId !== "string" || !/^[a-zA-Z0-9_-]{1,100}$/.test(options.windowId))) throw new SparkError("E_INVALID_ARGUMENT", "Invalid shortcut windowId");
+  if (options.repeat !== undefined && typeof options.repeat !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "Shortcut repeat must be boolean");
+  const parsed = parseAccelerator(accelerator, Platform.OS === "windows" ? "windows" : "macos");
   const id = `shortcut-${Date.now()}-${++nextID}`;
-  const parsed = parseAccelerator(Platform.OS === "windows" ? accelerator.replace(/commandorcontrol|cmdorctrl/ig, "Control") : accelerator);
   let removed = false;
-  const subscription = emitter.addListener("shortcut", (event: { id: string }) => { if (!removed && event.id === id) handler(); });
-  try { await Native.call("register", JSON.stringify({ id, ...parsed, ...options })); }
-  catch (error) { subscription.remove(); throw error; }
-  return { async remove() {
-    if (removed) return;
-    removed = true; subscription.remove(); await Native.call("remove", JSON.stringify({ id }));
-  } };
+  const module = native();
+  const subscription = new NativeEventEmitter(module).addListener("shortcut", (event: unknown) => {
+    if (!removed && event && typeof event === "object" && (event as { id?: unknown }).id === id) {
+      try { handler(); }
+      catch (cause) { console.error(new SparkError("E_NATIVE", "Shortcut handler failed", { cause })); }
+    }
+  });
+  try { await call("register", { id, ...parsed, ...options }); }
+  catch (cause) {
+    removed = true; subscription.remove();
+    try { await call("remove", { id }); }
+    catch (cleanup) { throw new SparkError("E_NATIVE", "Shortcut registration and cleanup failed", { cause: new AggregateError([cause, cleanup]) }); }
+    throw cause;
+  }
+  return asyncRegistration(() => { removed = true; subscription.remove(); }, async () => { await call("remove", { id }); });
 }
 let nextID = 0;

package/vendor/node_modules/@legendapp/spark-desktop-shortcuts/src/keyboard-manager/NativeKeyboardManager.ts

@@ -0,0 +1,12 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+
+export interface Spec extends TurboModule {
+  startMonitoringKeyboard(): Promise<boolean>;
+  stopMonitoringKeyboard(): Promise<boolean>;
+  setConsumption(ownerId: string, rulesJson: string, capture: boolean): Promise<boolean>;
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.get<Spec>("NativeKeyboardManager");

package/vendor/node_modules/@legendapp/spark-desktop-shortcuts/src/keyboard-manager/codes.ts

@@ -0,0 +1,108 @@
+export const KeyCodes = {
+  KEY_A: 0,
+  KEY_S: 1,
+  KEY_D: 2,
+  KEY_F: 3,
+  KEY_H: 4,
+  KEY_G: 5,
+  KEY_Z: 6,
+  KEY_X: 7,
+  KEY_C: 8,
+  KEY_V: 9,
+  KEY_B: 11,
+  KEY_Q: 12,
+  KEY_W: 13,
+  KEY_E: 14,
+  KEY_R: 15,
+  KEY_Y: 16,
+  KEY_T: 17,
+  KEY_1: 18,
+  KEY_2: 19,
+  KEY_3: 20,
+  KEY_4: 21,
+  KEY_6: 22,
+  KEY_5: 23,
+  KEY_EQUALS: 24,
+  KEY_9: 25,
+  KEY_7: 26,
+  KEY_MINUS: 27,
+  KEY_8: 28,
+  KEY_0: 29,
+  KEY_RIGHT_BRACKET: 30,
+  KEY_O: 31,
+  KEY_U: 32,
+  KEY_LEFT_BRACKET: 33,
+  KEY_I: 34,
+  KEY_P: 35,
+  KEY_RETURN: 36,
+  KEY_L: 37,
+  KEY_J: 38,
+  KEY_K: 40,
+  KEY_COMMA: 43,
+  KEY_SLASH: 44,
+  KEY_N: 45,
+  KEY_M: 46,
+  KEY_PERIOD: 47,
+  KEY_TAB: 48,
+  KEY_SPACE: 49,
+  KEY_DELETE: 51,
+  KEY_BACKSPACE: 51,
+  KEY_ESCAPE: 53,
+  KEY_F17: 64,
+  KEY_F18: 79,
+  KEY_F19: 80,
+  KEY_F20: 90,
+  KEY_F5: 96,
+  KEY_F6: 97,
+  KEY_F7: 98,
+  KEY_F3: 99,
+  KEY_F8: 100,
+  KEY_F9: 101,
+  KEY_F11: 103,
+  KEY_F16: 106,
+  KEY_F14: 107,
+  KEY_F10: 109,
+  KEY_F12: 111,
+  KEY_F15: 113,
+  KEY_HELP: 114,
+  KEY_HOME: 115,
+  KEY_PAGE_UP: 116,
+  KEY_FORWARD_DELETE: 117,
+  KEY_F4: 118,
+  KEY_END: 119,
+  KEY_F2: 120,
+  KEY_PAGE_DOWN: 121,
+  KEY_F1: 122,
+  KEY_LEFT: 123,
+  KEY_RIGHT: 124,
+  KEY_DOWN: 125,
+  KEY_UP: 126,
+  KEY_MEDIA_PLAY_PAUSE: 10001,
+  KEY_MEDIA_NEXT: 10002,
+  KEY_MEDIA_PREVIOUS: 10003,
+  MODIFIER_CAPS_LOCK: 1 << 16,
+  MODIFIER_SHIFT: 1 << 17,
+  MODIFIER_CONTROL: 1 << 18,
+  MODIFIER_OPTION: 1 << 19,
+  MODIFIER_COMMAND: 1 << 20,
+  MODIFIER_FUNCTION: 1 << 23,
+} as const;
+
+export const KeyText: Record<number, string> = {
+  [KeyCodes.KEY_RETURN]: "Return",
+  [KeyCodes.KEY_TAB]: "Tab",
+  [KeyCodes.KEY_SPACE]: "Space",
+  [KeyCodes.KEY_DELETE]: "Delete",
+  [KeyCodes.KEY_FORWARD_DELETE]: "Forward Delete",
+  [KeyCodes.KEY_ESCAPE]: "Esc",
+  [KeyCodes.KEY_LEFT_BRACKET]: "[",
+  [KeyCodes.KEY_RIGHT_BRACKET]: "]",
+  [KeyCodes.KEY_LEFT]: "Left",
+  [KeyCodes.KEY_RIGHT]: "Right",
+  [KeyCodes.KEY_DOWN]: "Down",
+  [KeyCodes.KEY_UP]: "Up",
+  [KeyCodes.KEY_MEDIA_PLAY_PAUSE]: "Play/Pause",
+  [KeyCodes.KEY_MEDIA_NEXT]: "Next Track",
+  [KeyCodes.KEY_MEDIA_PREVIOUS]: "Previous Track",
+};
+

package/vendor/node_modules/@legendapp/spark-desktop-shortcuts/src/keyboard-manager/index.ts

@@ -0,0 +1,99 @@
+import { NativeEventEmitter, Platform } from "react-native";
+import Native from "./NativeKeyboardManager";
+import { SparkError, asyncRegistration, invokeNative, type AsyncRegistration, type Availability, type Subscription } from "@legendapp/spark-desktop-app/src/contracts";
+export type { AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+export { KeyCodes, KeyText } from "./codes";
+export type KeyboardEvent = Readonly<{ repeated: boolean; consumed: boolean; captured: boolean; windowId: string | null; key: string; keyCode: number; modifiers: number }>;
+export type KeyboardEventListener = (event: KeyboardEvent) => void;
+export type KeyboardListenerOptions = { windowIds?: readonly string[] };
+type Entry = { type: "down" | "up"; listener: KeyboardEventListener; windowIds?: readonly string[] };
+const entries = new Set<Entry>(), consumers = new Set<string>();
+let sequence = 0;
+let subscriptions: Subscription[] = [], monitoring = false, transitions = Promise.resolve();
+export function getKeyboardAvailability(): Availability {
+  if (Platform.OS !== "macos") return { available: false, reason: "unsupported-platform" };
+  return Native ? { available: true } : { available: false, reason: "missing-module" };
+}
+function native() {
+  const availability = getKeyboardAvailability();
+  if (!availability.available) throw new SparkError(availability.reason === "missing-module" ? "E_MODULE_UNAVAILABLE" : "E_UNSUPPORTED_PLATFORM", "Low-level keyboard monitoring requires a macOS host");
+  return Native!;
+}
+function notify(type: Entry["type"], value: unknown) {
+  if (!value || typeof value !== "object") return;
+  const event = value as KeyboardEvent;
+  if (typeof event.key !== "string" || !Number.isInteger(event.keyCode) || !Number.isInteger(event.modifiers) || typeof event.repeated !== "boolean" || typeof event.consumed !== "boolean" || typeof event.captured !== "boolean" || !(event.windowId === null || typeof event.windowId === "string")) return;
+  for (const entry of entries) {
+    if (entry.type !== type || (entry.windowIds && !(event.windowId !== null && entry.windowIds.includes(event.windowId)))) continue;
+    try { entry.listener(event); } catch (cause) { console.error(new SparkError("E_NATIVE", "Keyboard listener failed", { cause })); }
+  }
+}
+function synchronize(): Promise<void> {
+  const pending = transitions.then(async () => {
+    if ((entries.size || consumers.size) && !monitoring) {
+      const module = native(), emitter = new NativeEventEmitter(module);
+      subscriptions = [emitter.addListener("onKeyDown", event => notify("down", event)), emitter.addListener("onKeyUp", event => notify("up", event))];
+      try {
+        const started = await invokeNative(() => module.startMonitoringKeyboard());
+        if (started !== true) throw new SparkError("E_INVALID_DATA", "Keyboard monitor did not start");
+        monitoring = true;
+      } catch (error) { for (const subscription of subscriptions) subscription.remove(); subscriptions = []; throw error; }
+    } else if (!entries.size && !consumers.size && monitoring) {
+      const stopped = await invokeNative(() => native().stopMonitoringKeyboard());
+      if (stopped !== true) throw new SparkError("E_INVALID_DATA", "Keyboard monitor did not stop");
+      monitoring = false;
+      for (const subscription of subscriptions) subscription.remove(); subscriptions = [];
+    }
+  });
+  transitions = pending.catch(() => {}); return pending;
+}
+/** Nonblocking app-scoped observation. Return values never control native propagation. */
+export async function addKeyboardListener(type: "down" | "up", listener: KeyboardEventListener, options: KeyboardListenerOptions = {}): Promise<AsyncRegistration> {
+  if ((type !== "down" && type !== "up") || typeof listener !== "function" || !options || typeof options !== "object" || Array.isArray(options)) throw new SparkError("E_INVALID_ARGUMENT", "Expected keyboard event type, listener and options");
+  for (const key of Object.keys(options)) if (key !== "windowIds") throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown keyboard option: ${key}`);
+  if (options.windowIds !== undefined && (!Array.isArray(options.windowIds) || options.windowIds.some(id => typeof id !== "string" || !id))) throw new SparkError("E_INVALID_ARGUMENT", "Expected window IDs");
+  native();
+  const entry = { type, listener, windowIds: options.windowIds ? [...options.windowIds] : undefined };
+  entries.add(entry);
+  try { await synchronize(); } catch (error) { entries.delete(entry); throw error; }
+  return asyncRegistration(() => { entries.delete(entry); }, synchronize);
+}
+export function hasModifier(event: Pick<KeyboardEvent, "modifiers">, modifier: number): boolean { return (event.modifiers & modifier) === modifier; }
+export function createModifierMask(...modifiers: number[]): number { return modifiers.reduce((mask, modifier) => mask | modifier, 0); }
+
+
+/** Internal compiled rules, shared by command routing and keyboard capture. */
+export interface KeyboardConsumptionRule {
+  key: string; modifiers: number; allowExtraModifiers: boolean; repeat: boolean;
+  windowIds?: readonly string[]; excludedWindowIds?: readonly string[];
+}
+export interface KeyboardConsumption extends AsyncRegistration { update(rules: readonly KeyboardConsumptionRule[]): Promise<void> }
+export async function createKeyboardConsumption(rules: readonly KeyboardConsumptionRule[], capture = false): Promise<KeyboardConsumption> {
+  const module = native(), id = `keyboard-${++sequence}`;
+  const publish = async (value: readonly KeyboardConsumptionRule[], capturing = capture) => {
+    const json = JSON.stringify(value);
+    const result = await invokeNative(() => module.setConsumption(id, json, capturing));
+    if (result !== true) throw new SparkError("E_INVALID_DATA", "Keyboard consumption update was not acknowledged");
+  };
+  consumers.add(id);
+  try { await synchronize(); await publish(rules); }
+  catch (error) {
+    consumers.delete(id);
+    try { await publish([], false); await synchronize(); }
+    catch (cleanupError) { throw new AggregateError([error, cleanupError], "Keyboard consumption setup and cleanup failed"); }
+    throw error;
+  }
+  let closed = false, pending: Promise<unknown> = Promise.resolve();
+  const removal = asyncRegistration(() => { closed = true; }, async () => {
+    await pending.catch(() => {});
+    await publish([], false); consumers.delete(id); await synchronize();
+  });
+  return {
+    remove: removal.remove,
+    update(value) {
+      if (closed) return Promise.reject(new SparkError("E_CLOSED", "Keyboard consumption has been removed"));
+      // Submit now: the module's main queue owns update ordering and snapshots.
+      const result = publish(value); pending = result; return result;
+    },
+  };
+}

package/vendor/node_modules/@legendapp/spark-desktop-windows/RNDesktopWindows.podspec

@@ -14,4 +14,6 @@ Pod::Spec.new do |s|
   s.dependency "ReactCodegen"
   s.dependency "RNDesktopApp"
   s.dependency "React-RCTAppDelegate"
+  s.osx.frameworks = "AppKit", "CoreImage", "QuartzCore"
+  s.dependency "React-cxxreact"
 end