@legendapp/spark 0.0.1-next.2

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

@@ -0,0 +1,43 @@
+{
+  "name": "@legendapp/spark-desktop-shortcuts",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "main": "src/index",
+  "react-native": "src/index",
+  "files": [
+    "src",
+    "macos",
+    "*.podspec"
+  ],
+  "peerDependencies": {
+    "react": "19.1.4",
+    "react-native": "0.81.6"
+  },
+  "codegenConfig": {
+    "name": "RNDesktopShortcutsSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "ios": {
+      "modulesProvider": {
+        "NativeDesktopShortcuts": "RNDesktopShortcuts"
+      }
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "nativeModules": [
+      "NativeDesktopShortcuts"
+    ],
+    "pod": "RNDesktopShortcuts",
+    "platforms": [
+      "macos"
+    ],
+    "requires": [
+      "@legendapp/spark-desktop-app"
+    ]
+  },
+  "dependencies": {
+    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+  },
+  "private": true
+}

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

@@ -0,0 +1,8 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+export interface Spec extends TurboModule {
+  call(method: string, args: string): Promise<string>;
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopShortcuts");

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

@@ -0,0 +1,22 @@
+export type Accelerator = { key: string; modifiers: number };
+// AppKit uses these bit positions in NSEventModifierFlags.
+const modifiers: Record<string, number> = {
+  cmd: 1 << 20, command: 1 << 20, meta: 1 << 20, commandorcontrol: 1 << 20, cmdorctrl: 1 << 20,
+  ctrl: 1 << 18, control: 1 << 18, alt: 1 << 19, option: 1 << 19, shift: 1 << 17,
+};
+const named: Record<string, string> = { enter: "\r", return: "\r", escape: "\u001b", esc: "\u001b", tab: "\t", space: " ", backspace: "\u007f", delete: "\uf728", up: "\uf700", down: "\uf701", left: "\uf702", right: "\uf703", plus: "+" };
+export function parseAccelerator(value: string): Accelerator {
+  const parts = value.toLowerCase().split("+").map(part => part.trim());
+  let flags = 0;
+  for (const part of parts.slice(0, -1)) {
+    const flag = modifiers[part];
+    if (!flag || (flags & flag)) throw new Error(`Invalid or duplicate modifier: ${part}`);
+    flags |= flag;
+  }
+  const last = parts.at(-1)!;
+  let key = named[last] ?? last;
+  if (/^f([1-9]|1[0-9]|20)$/.test(last)) key = String.fromCharCode(0xf704 + Number(last.slice(1)) - 1);
+  if ([...key].length !== 1) throw new Error(`Unknown shortcut key: ${last}`);
+  if (!flags && !named[last] && !/^f([1-9]|1[0-9]|20)$/.test(last)) throw new Error("Character shortcuts need a modifier");
+  return { key, modifiers: flags };
+}

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

@@ -0,0 +1,20 @@
+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 = {}) {
+  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 }));
+  } };
+}
+let nextID = 0;

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

@@ -0,0 +1 @@
+export * from "./api";

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

@@ -0,0 +1 @@
+export * from "./api";

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

@@ -0,0 +1,17 @@
+require "json"
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+Pod::Spec.new do |s|
+  s.name = "RNDesktopWindows"
+  s.version = package["version"]
+  s.summary = "Desktop desktop-windows"
+  s.license = { :type => "MIT" }
+  s.author = "Legend"
+  s.homepage = "https://legendapp.com"
+  s.source = { :path => "." }
+  s.platforms = { :osx => "14.0" }
+  s.source_files = "macos/**/*.{h,m,mm}"
+  s.dependency "React-Core"
+  s.dependency "ReactCodegen"
+  s.dependency "RNDesktopApp"
+  s.dependency "React-RCTAppDelegate"
+end

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

@@ -0,0 +1,4 @@
+#import <RNDesktopWindowsSpec/RNDesktopWindowsSpec.h>
+#import <Foundation/Foundation.h>
+@interface RNDesktopWindows : NSObject <NativeDesktopWindowManagerSpec>
+@end

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

@@ -0,0 +1,210 @@
+#import "RNDesktopWindows.h"
+#import <RNDesktopApp/SparkDesktop.h>
+#import <React-RCTAppDelegate/RCTRootViewFactory.h>
+#import <React/RCTSurfaceHostingView.h>
+
+// Overlay controls accept mouse input without taking keyboard focus from an app.
+@interface SparkOverlayPanel : NSPanel
+@end
+@implementation SparkOverlayPanel
+- (BOOL)canBecomeKeyWindow { return NO; }
+- (BOOL)canBecomeMainWindow { return NO; }
+@end
+static void Show(NSWindow *window) {
+  if ([window isKindOfClass:SparkOverlayPanel.class]) [window orderFrontRegardless];
+  else [window makeKeyAndOrderFront:nil];
+}
+@protocol SparkRootFactory
+- (RCTRootViewFactory *)rootViewFactory;
+@end
+@interface SparkWindowDelegate : NSObject <NSWindowDelegate>
+@property NSString *windowID;
+@property BOOL guarded;
+@property BOOL allowingClose;
+@property NSUInteger request;
+@property BOOL pending;
+- (void)requestClose;
+@end
+static NSMutableDictionary<NSString *, NSWindow *> *windows;
+static NSMutableDictionary<NSString *, SparkWindowDelegate *> *delegates;
+static NSWindow *Window(NSString *key) {
+  if (!windows) windows = [NSMutableDictionary new];
+  NSWindow *window = windows[key];
+  if (!window && [key isEqual:@"main"]) {
+    for (NSWindow *candidate in NSApp.windows) {
+      if ([candidate.identifier isEqual:@"spark.main"]) { window = candidate; break; }
+    }
+    if (window) windows[key] = window;
+  }
+  return window;
+}
+static void Event(NSString *type, NSString *key) { SparkEmit(@{ @"type": type, @"windowId": key }); }
+@implementation SparkWindowDelegate
+- (void)requestClose {
+  if (self.pending) return;
+  self.pending = YES; NSUInteger request = ++self.request;
+  SparkEmit(@{ @"type": @"beforeClose", @"windowId": self.windowID, @"requestId": @(request) });
+  __weak SparkWindowDelegate *weakSelf = self;
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 30 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+    SparkWindowDelegate *delegate = weakSelf;
+    if (delegate.request == request) delegate.pending = NO;
+  });
+}
+- (BOOL)windowShouldClose:(NSWindow *)sender {
+  if (self.guarded && !self.allowingClose) { [self requestClose]; return NO; }
+  return YES;
+}
+- (void)windowWillClose:(NSNotification *)note {
+  NSWindow *closing = note.object;
+  if (closing.sheetParent) [closing.sheetParent endSheet:closing];
+  if (closing.parentWindow) [closing.parentWindow removeChildWindow:closing];
+  Event(@"closed", self.windowID);
+  if (![self.windowID isEqual:@"main"]) {
+    NSWindow *window = note.object;
+    NSView *root = [window.contentView isKindOfClass:NSVisualEffectView.class] ? window.contentView.subviews.firstObject : window.contentView;
+    if ([root isKindOfClass:RCTSurfaceHostingView.class]) [((RCTSurfaceHostingView *)root).surface stop];
+    [root removeFromSuperview];
+    window.contentView = [[NSView alloc] initWithFrame:root.frame];
+    [windows removeObjectForKey:self.windowID];
+    // Retain self until the delegate callback returns.
+    dispatch_async(dispatch_get_main_queue(), ^{ [delegates removeObjectForKey:self.windowID]; });
+  }
+}
+- (void)windowDidMove:(NSNotification *)note { Event(@"move", self.windowID); }
+- (void)windowDidResize:(NSNotification *)note { Event(@"resize", self.windowID); }
+- (void)windowDidChangeScreen:(NSNotification *)note { Event(@"screenChanged", self.windowID); }
+- (void)windowDidEnterFullScreen:(NSNotification *)note { Event(@"enterFullscreen", self.windowID); }
+- (void)windowDidExitFullScreen:(NSNotification *)note { Event(@"leaveFullscreen", self.windowID); }
+- (void)windowDidBecomeKey:(NSNotification *)note { Event(@"focus", self.windowID); }
+- (void)windowDidResignKey:(NSNotification *)note { Event(@"blur", self.windowID); }
+@end
+static void InstallDelegate(NSWindow *window, NSString *key) {
+  if (!delegates) delegates = [NSMutableDictionary new];
+  if (delegates[key]) return;
+  SparkWindowDelegate *delegate = [SparkWindowDelegate new];
+  delegate.windowID = key;
+  delegates[key] = delegate;
+  window.delegate = delegate;
+}
+static void RequestClose(NSWindow *window, NSString *key) {
+  SparkWindowDelegate *delegate = delegates[key];
+  if (delegate.guarded && !delegate.allowingClose) { [delegate requestClose]; return; }
+  if (window.sheetParent) [window.sheetParent endSheet:window];
+  [window close];
+}
+static NSDictionary *Frame(NSRect frame) {
+  return @{ @"x": @(frame.origin.x), @"y": @(frame.origin.y), @"width": @(frame.size.width), @"height": @(frame.size.height) };
+}
+static NSDictionary *Info(NSString *key, NSWindow *window) {
+  return @{ @"id": key, @"kind": [window isKindOfClass:SparkOverlayPanel.class] ? @"overlay" : @"window", @"title": window.title, @"visible": @(window.visible), @"focused": @(window.keyWindow),
+    @"resizable": @((window.styleMask & NSWindowStyleMaskResizable) != 0), @"alwaysOnTop": @(window.level >= NSFloatingWindowLevel),
+    @"minWidth": @(window.contentMinSize.width), @"maxWidth": @(window.contentMaxSize.width),
+    @"minimized": @(window.miniaturized), @"fullscreen": @((window.styleMask & NSWindowStyleMaskFullScreen) != 0), @"frame": Frame(window.frame) };
+}
+@implementation RNDesktopWindows
+RCT_EXPORT_MODULE(NativeDesktopWindowManager)
++ (BOOL)requiresMainQueueSetup { return YES; }
+- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSDictionary *args = SparkArgs(json);
+    NSString *key = [args[@"id"] isKindOfClass:NSString.class] ? args[@"id"] : @"main";
+    NSWindow *main = Window(@"main");
+    if (main) InstallDelegate(main, @"main");
+    if ([method isEqual:@"displays"]) {
+      NSMutableArray *result = [NSMutableArray new];
+      for (NSScreen *screen in NSScreen.screens) [result addObject:@{ @"id": [screen.deviceDescription[@"NSScreenNumber"] stringValue],
+        @"name": screen.localizedName, @"frame": Frame(screen.frame), @"workArea": Frame(screen.visibleFrame), @"scale": @(screen.backingScaleFactor) }];
+      resolve(SparkJSON(result)); return;
+    }
+    if ([method isEqual:@"list"]) {
+      NSMutableArray *result = [NSMutableArray new];
+      for (NSString *windowID in windows) [result addObject:Info(windowID, windows[windowID])];
+      resolve(SparkJSON(result)); return;
+    }
+    NSWindow *window = Window(key);
+    if ([method isEqual:@"open"]) {
+      if (!key.length || [key isEqual:@"main"]) { SparkInvalid(reject, @"Secondary windows need a non-main id"); return; }
+      NSWindow *parent = args[@"parentId"] ? Window(args[@"parentId"]) : nil;
+      if (args[@"parentId"] && !parent) { reject(@"E_NOT_FOUND", @"Parent window not found", nil); return; }
+      if (parent && parent == window) { SparkInvalid(reject, @"Invalid parent window"); return; }
+      if ([args[@"modal"] boolValue] && (!parent || parent.attachedSheet)) { reject(@"E_BUSY", @"Modal window requires an available parent", nil); return; }
+      if (!window) {
+        id delegate = NSApp.delegate;
+        if (![delegate respondsToSelector:@selector(rootViewFactory)]) { reject(@"E_HOST", @"Host has no React root factory", nil); return; }
+        CGFloat width = args[@"width"] ? [args[@"width"] doubleValue] : 640;
+        CGFloat height = args[@"height"] ? [args[@"height"] doubleValue] : 480;
+        BOOL overlay = [args[@"kind"] isEqual:@"overlay"];
+        if (overlay && [args[@"modal"] boolValue]) { SparkInvalid(reject, @"An overlay cannot be modal"); return; }
+        window = [[(overlay ? SparkOverlayPanel.class : NSWindow.class) alloc] initWithContentRect:NSMakeRect(0, 0, width, height)
+          styleMask:NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable | NSWindowStyleMaskResizable | (overlay ? NSWindowStyleMaskNonactivatingPanel : 0)
+          backing:NSBackingStoreBuffered defer:NO];
+        if (overlay) {
+          ((NSPanel *)window).hidesOnDeactivate = NO;
+          window.collectionBehavior = NSWindowCollectionBehaviorCanJoinAllSpaces | NSWindowCollectionBehaviorFullScreenAuxiliary;
+        }
+        window.releasedWhenClosed = NO;
+        window.identifier = [@"spark." stringByAppendingString:key];
+        window.title = args[@"title"] ?: SparkContext()[@"name"];
+        window.contentView = [(id<SparkRootFactory>)delegate rootViewFactory] ? [[(id<SparkRootFactory>)delegate rootViewFactory]
+          viewWithModuleName:@"main" initialProperties:SparkInitialProps(key, args[@"props"])] : nil;
+        window.contentView = SparkWindowContent(window.contentView);
+        SparkApplyWindowOptions(window, args);
+        SparkRestoreWindow(window, key, args);
+        windows[key] = window;
+        InstallDelegate(window, key);
+        Event(@"opened", key);
+      }
+      if ([args[@"modal"] boolValue]) [parent beginSheet:window completionHandler:nil];
+      else { NSInteger level = window.level; if (parent) [parent addChildWindow:window ordered:NSWindowAbove]; Show(window); window.level = level; }
+      resolve(SparkJSON(Info(key, window))); return;
+    }
+    if (!window) { reject(@"E_NOT_FOUND", @"Window does not exist", nil); return; }
+    if ([method isEqual:@"info"]) { resolve(SparkJSON(Info(key, window))); return; }
+    if ([method isEqual:@"close"]) RequestClose(window, key);
+    else if ([method isEqual:@"closeGuard"]) { delegates[key].guarded = [args[@"enabled"] boolValue]; delegates[key].pending = NO; delegates[key].request++; }
+    else if ([method isEqual:@"replyClose"]) {
+      SparkWindowDelegate *delegate = delegates[key];
+      if (delegate.pending && delegate.request == [args[@"requestId"] unsignedIntegerValue]) {
+        delegate.pending = NO;
+        if ([args[@"allow"] boolValue]) { delegate.allowingClose = YES; RequestClose(window, key); delegate.allowingClose = NO; }
+      }
+    }
+    else if ([method isEqual:@"show"]) { [window deminiaturize:nil]; Show(window); }
+    else if ([method isEqual:@"options"]) SparkApplyWindowOptions(window, args[@"options"]);
+    else if ([method isEqual:@"maximize"]) { if (!window.zoomed) [window zoom:nil]; }
+    else if ([method isEqual:@"unmaximize"]) { if (window.zoomed) [window zoom:nil]; }
+    else if ([method isEqual:@"center"]) [window center];
+    else if ([method isEqual:@"hide"]) [window orderOut:nil];
+    else if ([method isEqual:@"minimize"]) [window miniaturize:nil];
+    else if ([method isEqual:@"fullscreen"]) {
+      BOOL current = (window.styleMask & NSWindowStyleMaskFullScreen) != 0;
+      if (current != [args[@"enabled"] boolValue]) [window toggleFullScreen:nil];
+    }
+    else if ([method isEqual:@"title"]) window.title = args[@"title"] ?: @"";
+    else if ([method isEqual:@"frame"]) {
+      NSDictionary *frame = args[@"frame"];
+      [window setFrame:NSMakeRect([frame[@"x"] doubleValue], [frame[@"y"] doubleValue], [frame[@"width"] doubleValue], [frame[@"height"] doubleValue]) display:YES];
+    }
+    else { SparkInvalid(reject, @"Unknown window operation"); return; }
+    resolve(@"null");
+  });
+}
+- (void)invalidate {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    for (NSString *key in [windows.allKeys copy]) {
+      NSWindow *window = windows[key];
+      window.delegate = nil;
+      if (![key isEqual:@"main"]) {
+        NSView *root = [window.contentView isKindOfClass:NSVisualEffectView.class] ? window.contentView.subviews.firstObject : window.contentView;
+        if ([root isKindOfClass:RCTSurfaceHostingView.class]) [((RCTSurfaceHostingView *)root).surface stop];
+        [root removeFromSuperview]; window.contentView = nil;
+        [window close];
+      }
+    }
+    [windows removeAllObjects]; [delegates removeAllObjects];
+  });
+}
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeDesktopWindowManagerSpecJSI>(params);
+}
+@end

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

@@ -0,0 +1,44 @@
+{
+  "name": "@legendapp/spark-desktop-windows",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "main": "src/index",
+  "react-native": "src/index",
+  "files": [
+    "src",
+    "macos",
+    "*.podspec"
+  ],
+  "peerDependencies": {
+    "react": "19.1.4",
+    "react-native": "0.81.6"
+  },
+  "codegenConfig": {
+    "name": "RNDesktopWindowsSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "ios": {
+      "modulesProvider": {
+        "NativeDesktopWindowManager": "RNDesktopWindows"
+      }
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "nativeModules": [
+      "NativeDesktopWindowManager"
+    ],
+    "pod": "RNDesktopWindows",
+    "platforms": [
+      "macos"
+    ],
+    "requires": [
+      "@legendapp/spark-desktop-app"
+    ]
+  },
+  "dependencies": {
+    "@legendapp/spark-desktop-app": "0.0.1-next.2",
+    "@legendapp/spark-window-options": "0.0.1-next.2"
+  },
+  "private": true
+}

package/vendor/node_modules/@legendapp/spark-desktop-windows/src/NativeDesktopWindowManager.ts

@@ -0,0 +1,6 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+export interface Spec extends TurboModule {
+  call(method: string, args: string): Promise<string>;
+}
+export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopWindowManager");

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

@@ -0,0 +1,79 @@
+import { validateWindow, type WindowStyle } from "@legendapp/spark-window-options";
+export type { WindowStyle } from "@legendapp/spark-window-options";
+import Native from "./NativeDesktopWindowManager";
+import { Platform } from "react-native";
+import { validateWindowsWindowOptions } from "./windows-options";
+import { onDesktopEvent } from "@legendapp/spark-desktop-app";
+export type Frame = { x: number; y: number; width: number; height: number };
+export type WindowInfo = { id: string; kind: "window" | "overlay"; title: string; visible: boolean; focused: boolean; resizable: boolean; alwaysOnTop: boolean; minWidth: number; maxWidth: number; minimized: boolean; fullscreen: boolean; frame: Frame };
+export type Display = { id: string; name: string; frame: Frame; workArea: Frame; scale: number };
+export type WindowOptions = WindowStyle & { id: string; kind?: "window" | "overlay"; parentId?: string; modal?: boolean; props?: Record<string, unknown> };
+export type WindowEvent = { type: string; windowId: string; requestId?: number };
+async function call<T = void>(method: string, args: object = {}): Promise<T> {
+  return JSON.parse(await Native.call(method, JSON.stringify(args))) as T;
+}
+function id(value: string) { if (!/^[a-zA-Z0-9_-]{1,100}$/.test(value)) throw new Error("Window id must contain 1–100 letters, numbers, underscores or hyphens"); return value; }
+function dimension(value: number) { if (!Number.isFinite(value) || value < 100 || value > 20000) throw new Error("Window dimensions must be between 100 and 20000 points"); }
+export function openWindow(options: WindowOptions) {
+  id(options.id); if (options.id === "main") throw new Error("Use showWindow for the main window");
+  if (options.kind !== undefined && !["window", "overlay"].includes(options.kind)) throw new Error("Invalid window kind");
+  if (options.kind === "overlay" && options.modal) throw new Error("An overlay cannot be modal");
+  options = options.kind === "overlay" ? { titleBarStyle: "borderless", transparent: true, hasShadow: false, alwaysOnTop: true, resizable: false, minimizable: false, ...options } : options;
+  const { id: _id, kind, parentId, modal, props, ...style } = options;
+  validateWindow(style);
+  if (Platform.OS === "windows") {
+    validateWindowsWindowOptions(style);
+  }
+  if (parentId !== undefined) id(parentId);
+  if (parentId === options.id || (modal && !parentId)) throw new Error("Modal windows need a distinct parent");
+  return call<WindowInfo>("open", options);
+}
+export function setWindowOptions(windowId: string, options: WindowStyle) {
+  validateWindow(options);
+  if (Platform.OS === "windows") validateWindowsWindowOptions(options);
+  return call("options", { id: id(windowId), options });
+}
+export const maximizeWindow = (windowId = "main") => call("maximize", { id: id(windowId) });
+export const unmaximizeWindow = (windowId = "main") => call("unmaximize", { id: id(windowId) });
+export const centerWindow = (windowId = "main") => call("center", { id: id(windowId) });
+export const listWindows = () => call<WindowInfo[]>("list");
+export const getDisplays = () => call<Display[]>("displays");
+export const getWindow = (windowId = "main") => call<WindowInfo>("info", { id: id(windowId) });
+export const closeWindow = (windowId = "main") => call("close", { id: id(windowId) });
+export const showWindow = (windowId = "main") => call("show", { id: id(windowId) });
+export const hideWindow = (windowId = "main") => call("hide", { id: id(windowId) });
+export const minimizeWindow = (windowId = "main") => call("minimize", { id: id(windowId) });
+export const setFullscreen = (windowId: string, enabled: boolean) => call("fullscreen", { id: id(windowId), enabled });
+export const setWindowTitle = (windowId: string, title: string) => call("title", { id: id(windowId), title });
+/** macOS uses screen points with a bottom-left origin; Windows uses virtual-screen pixels with a top-left origin. */
+export function setWindowFrame(windowId: string, frame: Frame) {
+  dimension(frame.width); dimension(frame.height);
+  if (!Number.isFinite(frame.x) || !Number.isFinite(frame.y)) throw new Error("Frame origin must be finite");
+  return call("frame", { id: id(windowId), frame });
+}
+export function onWindowEvent(listener: (event: WindowEvent) => void) {
+  return onDesktopEvent(event => { if (typeof event.windowId === "string") listener(event as WindowEvent); });
+}
+const guards = new Set<string>();
+export async function beforeWindowClose(windowId: string, handler: () => boolean | Promise<boolean>) {
+  id(windowId);
+  if (guards.has(windowId)) throw new Error("This window already has a close handler");
+  guards.add(windowId); let removed = false; let pending: number | undefined;
+  const subscription = onWindowEvent(event => {
+    if (event.windowId !== windowId || event.type !== "beforeClose" || pending === event.requestId) return;
+    pending = event.requestId;
+    void Promise.resolve().then(handler).then(
+      allow => call("replyClose", { id: windowId, requestId: event.requestId, allow: !removed && allow === true }),
+      () => call("replyClose", { id: windowId, requestId: event.requestId, allow: false }),
+    ).catch(console.error).finally(() => { if (pending === event.requestId) pending = undefined; });
+  });
+  try { await call("closeGuard", { id: windowId, enabled: true }); }
+  catch (error) { subscription.remove(); guards.delete(windowId); throw error; }
+  return { async remove() {
+    if (removed) return;
+    removed = true; subscription.remove(); guards.delete(windowId);
+    // Closed secondary windows no longer have a native guard to remove.
+    try { await call("closeGuard", { id: windowId, enabled: false }); }
+    catch (error) { if ((error as { code?: string }).code !== "E_NOT_FOUND") throw error; }
+  } };
+}

package/vendor/node_modules/@legendapp/spark-desktop-windows/src/index.ts

@@ -0,0 +1 @@
+export * from "./api";

package/vendor/node_modules/@legendapp/spark-desktop-windows/src/index.windows.ts

@@ -0,0 +1 @@
+export * from "./api";

package/vendor/node_modules/@legendapp/spark-desktop-windows/src/windows-options.ts

@@ -0,0 +1,11 @@
+// AppKit materials and the overlay titlebar remain platform-specific.
+const windowsWindowOptions = new Set([
+  "title", "width", "height", "minWidth", "minHeight", "maxWidth", "maxHeight",
+  "resizable", "minimizable", "alwaysOnTop", "closable", "appearance", "backgroundColor", "restoreFrame", "titleBarStyle", "transparent", "hasShadow",
+]);
+export function validateWindowsWindowOptions(options: object) {
+  const style = (options as { titleBarStyle?: string }).titleBarStyle;
+  if (style === "overlay") throw Object.assign(new Error("Windows does not yet support the overlay titlebar style"), { code: "E_UNAVAILABLE" });
+  const unsupported = Object.keys(options).filter(key => !windowsWindowOptions.has(key));
+  if (unsupported.length) throw Object.assign(new Error(`Windows does not yet support window options: ${unsupported.join(", ")}`), { code: "E_UNAVAILABLE" });
+}

package/vendor/node_modules/@legendapp/spark-drag-drop/RNDesktopDrag.podspec

@@ -0,0 +1,20 @@
+require "json"
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+Pod::Spec.new do |s|
+  s.name = "RNDesktopDrag"
+  s.version = package["version"]
+  s.summary = "Desktop desktop-windows"
+  s.license = { :type => "MIT" }
+  s.author = "Legend"
+  s.homepage = "https://legendapp.com"
+  s.frameworks = "UniformTypeIdentifiers"
+  s.source = { :path => "." }
+  s.platforms = { :osx => "14.0" }
+  s.source_files = "macos/**/*.{h,m,mm}"
+  s.pod_target_xcconfig = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/Headers/Private/Yoga\"" }
+  s.dependency "React-RCTFabric"
+  s.dependency "React-Core"
+  s.dependency "ReactCodegen"
+  s.dependency "RNDesktopApp"
+  s.dependency "React-RCTAppDelegate"
+end

package/vendor/node_modules/@legendapp/spark-drag-drop/macos/RNDesktopDragView.h

@@ -0,0 +1,4 @@
+#import <React/RCTViewComponentView.h>
+#import <AppKit/AppKit.h>
+@interface RNDesktopDragView : RCTViewComponentView <NSDraggingSource>
+@end

package/vendor/node_modules/@legendapp/spark-drag-drop/macos/RNDesktopDragView.mm

@@ -0,0 +1,94 @@
+#import "RNDesktopDragView.h"
+#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
+#import <react/renderer/components/RNDesktopDragSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNDesktopDragSpec/EventEmitters.h>
+#import <react/renderer/components/RNDesktopDragSpec/Props.h>
+#import <react/renderer/components/RNDesktopDragSpec/RCTComponentViewHelpers.h>
+using namespace facebook::react;
+static std::string JSON(id value) { NSData *data = [NSJSONSerialization dataWithJSONObject:value options:0 error:nil]; NSString *json = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; return json.UTF8String ?: "{}"; }
+static NSDragOperation Operation(NSString *value) { return [value isEqual:@"move"] ? NSDragOperationMove : [value isEqual:@"link"] ? NSDragOperationLink : [value isEqual:@"copy"] ? NSDragOperationCopy : NSDragOperationNone; }
+static NSString *OperationName(NSDragOperation value) { return value == NSDragOperationMove ? @"move" : value == NSDragOperationLink ? @"link" : value == NSDragOperationCopy ? @"copy" : @"none"; }
+static NSPasteboardType CustomType(NSString *mime) { return [UTType typeWithMIMEType:mime].identifier; }
+static NSArray *PasteboardTypes(NSArray *types) {
+  NSMutableArray *result = [NSMutableArray new];
+  for (NSString *type in types) [result addObject:[type isEqual:@"files"] ? NSPasteboardTypeFileURL : [type isEqual:@"text"] ? NSPasteboardTypeString : [type isEqual:@"urls"] ? NSPasteboardTypeURL : CustomType(type)];
+  return result;
+}
+@implementation RNDesktopDragView {
+  NSDictionary *_source;
+  NSDictionary *_options;
+  BOOL _disabled;
+  BOOL _dragging;
+  BOOL _mouseDown;
+  NSPoint _start;
+}
+- (instancetype)init { if (self = [super init]) { _props = std::make_shared<const DesktopDragViewProps>(); [self registerForDraggedTypes:@[NSPasteboardTypeFileURL, NSPasteboardTypeURL, NSPasteboardTypeString]]; } return self; }
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &value = *std::static_pointer_cast<DesktopDragViewProps const>(props);
+  NSString *json = [NSString stringWithUTF8String:value.sourceJson.c_str()];
+  _source = json.length ? [NSJSONSerialization JSONObjectWithData:[json dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil] : nil;
+  NSString *options = [NSString stringWithUTF8String:value.optionsJson.c_str()];
+  _options = options.length ? [NSJSONSerialization JSONObjectWithData:[options dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil] : nil;
+  [self unregisterDraggedTypes]; [self registerForDraggedTypes:PasteboardTypes(_options[@"acceptedTypes"] ?: @[@"files", @"text", @"urls"])];
+  _disabled = value.disabled; [super updateProps:props oldProps:oldProps];
+}
+- (BOOL)isFlipped { return YES; }
+// Fabric parents call the UIKit-compatible overload directly when traversing children.
+- (NSView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event { NSView *hit = [super hitTest:point withEvent:event]; return hit && _source.count && !_disabled ? self : hit; }
+- (BOOL)mouseDownCanMoveWindow { return _source.count && !_disabled ? NO : [super mouseDownCanMoveWindow]; }
+- (NSDragOperation)operation:(id<NSDraggingInfo>)sender {
+  if (_disabled || ![sender.draggingPasteboard availableTypeFromArray:PasteboardTypes(_options[@"acceptedTypes"] ?: @[@"files", @"text", @"urls"])]) return NSDragOperationNone;
+  for (NSString *name in _options[@"acceptedOperations"] ?: @[@"copy"]) { NSDragOperation operation = Operation(name); if (sender.draggingSourceOperationMask & operation) return operation; }
+  return NSDragOperationNone;
+}
+- (NSDictionary *)position:(id<NSDraggingInfo>)sender {
+  NSPoint point = [self convertPoint:sender.draggingLocation fromView:nil];
+  return @{ @"x": @(point.x), @"y": @(point.y), @"operation": OperationName([self operation:sender]) };
+}
+- (NSDictionary *)payload:(id<NSDraggingInfo>)sender {
+  NSMutableArray *files = [NSMutableArray new], *urls = [NSMutableArray new]; NSPasteboard *board = sender.draggingPasteboard;
+  for (NSURL *url in [board readObjectsForClasses:@[NSURL.class] options:nil]) { if (url.fileURL) [files addObject:url.path]; else [urls addObject:url.absoluteString]; }
+  NSMutableDictionary *data = [NSMutableDictionary new];
+  for (NSString *type in _options[@"acceptedTypes"]) if ([type containsString:@"/"]) { NSString *value = [board stringForType:CustomType(type)]; if (value) data[type] = value; }
+  NSMutableDictionary *result = [[self position:sender] mutableCopy];
+  [result addEntriesFromDictionary:@{ @"files": files, @"urls": urls, @"text": [board stringForType:NSPasteboardTypeString] ?: @"", @"data": data }]; return result;
+}
+- (NSDragOperation)draggingEntered:(id<NSDraggingInfo>)sender {
+  NSDragOperation operation = [self operation:sender]; if (!operation) return operation;
+  auto emitter = std::static_pointer_cast<const DesktopDragViewEventEmitter>(_eventEmitter); if (emitter) emitter->onDragEnter({ JSON([self payload:sender]) }); return operation;
+}
+- (NSDragOperation)draggingUpdated:(id<NSDraggingInfo>)sender {
+  NSDragOperation operation = [self operation:sender];
+  auto emitter = std::static_pointer_cast<const DesktopDragViewEventEmitter>(_eventEmitter); if (emitter && operation) emitter->onDragOver({ JSON([self position:sender]) }); return operation;
+}
+- (void)draggingExited:(id<NSDraggingInfo>)sender { auto emitter = std::static_pointer_cast<const DesktopDragViewEventEmitter>(_eventEmitter); if (emitter) emitter->onDragLeave({ "{}" }); }
+- (BOOL)performDragOperation:(id<NSDraggingInfo>)sender { if (![self operation:sender]) return NO; auto emitter = std::static_pointer_cast<const DesktopDragViewEventEmitter>(_eventEmitter); if (!emitter) return NO; emitter->onDrop({ JSON([self payload:sender]) }); return YES; }
+- (void)mouseDown:(NSEvent *)event { _mouseDown = YES; _start = event.locationInWindow; if (!_source.count || _disabled) [super mouseDown:event]; }
+- (void)mouseUp:(NSEvent *)event { _mouseDown = NO; [super mouseUp:event]; }
+- (void)mouseDragged:(NSEvent *)event {
+  if (!_mouseDown || _dragging || _disabled || !_source.count || hypot(event.locationInWindow.x - _start.x, event.locationInWindow.y - _start.y) < 6) { [super mouseDragged:event]; return; }
+  NSMutableArray *writers = [NSMutableArray new];
+  for (NSString *file in _source[@"files"]) if ([file hasPrefix:@"/"]) [writers addObject:[NSURL fileURLWithPath:file]];
+  for (NSString *value in _source[@"urls"]) { NSURL *url = [NSURL URLWithString:value]; if (url) [writers addObject:url]; }
+  if (_source[@"text"]) [writers addObject:_source[@"text"]];
+  if ([_source[@"data"] count]) {
+    NSPasteboardItem *custom = [NSPasteboardItem new];
+    for (NSString *type in _source[@"data"]) [custom setString:_source[@"data"][type] forType:CustomType(type)];
+    [writers addObject:custom];
+  }
+  if (!writers.count) return;
+  NSMutableArray *items = [NSMutableArray new];
+  for (id<NSPasteboardWriting> writer in writers) {
+    NSDraggingItem *item = [[NSDraggingItem alloc] initWithPasteboardWriter:writer];
+    NSImage *image = [NSImage imageWithSystemSymbolName:@"doc" accessibilityDescription:@"Dragged item"];
+    [item setDraggingFrame:NSMakeRect(0, 0, 32, 32) contents:image]; [items addObject:item];
+  }
+  _dragging = YES; [self beginDraggingSessionWithItems:items event:event source:self];
+}
+- (NSDragOperation)draggingSession:(NSDraggingSession *)session sourceOperationMaskForDraggingContext:(NSDraggingContext)context { NSDragOperation mask = NSDragOperationNone; for (NSString *name in _options[@"sourceOperations"] ?: @[@"copy"]) mask |= Operation(name); return mask; }
+- (void)draggingSession:(NSDraggingSession *)session endedAtPoint:(NSPoint)point operation:(NSDragOperation)operation {
+  _dragging = NO; _mouseDown = NO; auto emitter = std::static_pointer_cast<const DesktopDragViewEventEmitter>(_eventEmitter); if (emitter) emitter->onDragEnd({ JSON(@{ @"accepted": @(operation != NSDragOperationNone), @"operation": OperationName(operation) }) });
+}
+- (void)prepareForRecycle { [super prepareForRecycle]; _source = nil; _options = nil; [self unregisterDraggedTypes]; [self registerForDraggedTypes:PasteboardTypes(@[@"files", @"text", @"urls"])]; _disabled = NO; _dragging = NO; _mouseDown = NO; _start = NSZeroPoint; }
++ (ComponentDescriptorProvider)componentDescriptorProvider { return concreteComponentDescriptorProvider<DesktopDragViewComponentDescriptor>(); }
+@end