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

package/vendor/node_modules/@legendapp/spark-desktop-windows/macos/window-manager/RNWindowManagerStartup.mm

@@ -0,0 +1,31 @@
+#import <TargetConditionals.h>
+#if TARGET_OS_OSX && __has_include(<RNDesktopApp/SparkLifecycle.h>)
+#import <RNDesktopApp/SparkLifecycle.h>
+extern "C" void LegendPrecreateRestorableWindows(void);
+extern "C" NSDictionary *LegendMainWindowStartupSplitViewConfiguration(void);
+extern "C" void LegendPrepareSidebarSplitViewStartup(NSWindow *, NSDictionary *) __attribute__((weak_import));
+extern "C" BOOL LegendAttachSidebarSplitViewStartupRoot(NSWindow *, NSView *, void (^)(void)) __attribute__((weak_import));
+
+@interface RNWindowManagerStartup : NSObject <SparkStartupPlugin>
+@end
+@implementation RNWindowManagerStartup
+- (void)prepareApplication { LegendPrecreateRestorableWindows(); }
+- (void)prepareMainWindow:(NSWindow *)window {
+  if ([SparkLifecycleConfiguration()[@"mainWindow"][@"hidden"] boolValue]) return;
+  NSDictionary *configuration = LegendMainWindowStartupSplitViewConfiguration();
+  NSDictionary *initial = [NSBundle.mainBundle objectForInfoDictionaryKey:@"LegendInitialSplitView"];
+  if (!configuration && initial) {
+    // Unshown AppKit windows may still report Aqua; match the host startup theme.
+    NSAppearance *appearance = window.appearance ?: NSApp.appearance;
+    BOOL dark = appearance
+      ? [[appearance bestMatchFromAppearancesWithNames:@[NSAppearanceNameDarkAqua, NSAppearanceNameAqua]] isEqualToString:NSAppearanceNameDarkAqua]
+      : [[[NSUserDefaults.standardUserDefaults stringForKey:@"AppleInterfaceStyle"] lowercaseString] isEqualToString:@"dark"];
+    configuration = initial[dark ? @"dark" : @"light"];
+  }
+  if (LegendPrepareSidebarSplitViewStartup && configuration) LegendPrepareSidebarSplitViewStartup(window, configuration);
+}
+- (void)attachRootView:(NSView *)root toWindow:(NSWindow *)window installRoot:(void (^)(void))installRoot {
+  if (!LegendAttachSidebarSplitViewStartupRoot || !LegendAttachSidebarSplitViewStartupRoot(window, root, installRoot)) installRoot();
+}
+@end
+#endif

package/vendor/node_modules/@legendapp/spark-desktop-windows/macos/window-manager/SidebarStartupFallbacks.mm

@@ -0,0 +1,14 @@
+#import <TargetConditionals.h>
+
+#if TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+
+// RNAppKitSplitView is optional. Supply linkable defaults for static release/LTO
+// builds; its strong definitions replace these when that pod is included.
+extern "C" __attribute__((weak)) void LegendPrepareSidebarSplitViewStartup(NSWindow *, NSDictionary *) {}
+extern "C" __attribute__((weak)) BOOL LegendAttachSidebarSplitViewStartupRoot(NSWindow *, NSView *, void (^)(void))
+{
+  return NO;
+}
+extern "C" __attribute__((weak)) void LegendFinishSidebarSplitViewStartup(NSWindow *) {}
+#endif

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

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-desktop-windows",
-  "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": {
-        "NativeDesktopWindowManager": "RNDesktopWindows"
-      }
+        "NativeDesktopWindowManager": "RNDesktopWindows",
+        "NativeWindowManager": "RNWindowManager"
+      },
+      "componentProvider": {}
     }
   },
   "spark": {
     "sdk": true,
     "nativeModules": [
-      "NativeDesktopWindowManager"
+      "NativeDesktopWindowManager",
+      "NativeWindowManager"
     ],
     "pod": "RNDesktopWindows",
     "platforms": [
@@ -37,8 +40,9 @@
     ]
   },
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.2",
-    "@legendapp/spark-window-options": "0.0.1-next.2"
+    "@legendapp/spark-desktop-app": "0.0.1-next.4",
+    "@legendapp/spark-window-options": "0.0.1-next.4",
+    "@legendapp/state": "^3.0.0-beta.42"
   },
   "private": true
 }

package/vendor/node_modules/@legendapp/spark-desktop-windows/src/NativeDesktopWindowManager.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>("NativeDesktopWindowManager");
+export default TurboModuleRegistry.get<Spec>("NativeDesktopWindowManager");

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

@@ -1,79 +1,155 @@
-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;
+import { SparkError, asyncRegistration, nativeError, type AsyncRegistration, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+export type { AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+import { onDesktopEvent } from "@legendapp/spark-desktop-app/src/events";
+import Native from "./NativeDesktopWindowManager";
+import { createMacOSWindow, macosNative, updateMacOSWindow } from "./macos-adapter";
+import { bounds, keys, number, object, text, validateOptions, windowId } from "./validation";
+import { getNativeDisplays, isBounds, isInfo, record, subscribeToWindowInstance, windowCall, windowCommand, type NativeWindowInfo } from "./transport";
+import type { CenterWindowOptions, CloseResult, CursorPoint, DisplayInfo, SetWindowBoundsOptions, ShowWindowOptions, WindowBounds, WindowEventMap, WindowInfo, WindowOpenOptions, WindowUpdateOptions } from "./types";
+export type * from "./types";
+
+export function getWindowAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  if (!Native) return { available: false, reason: "missing-module" };
+  if (Platform.OS === "macos") try { macosNative(); } catch { return { available: false, reason: "missing-module" }; }
+  return { available: true };
+}
+function publicInfo(value: NativeWindowInfo): WindowInfo {
+  const { id, kind, title, parentId, modal, visible, focused, minimized, maximized, fullscreen, bounds: { displayId, x, y, width, height } } = value;
+  return { id, kind, title, parentId, modal, visible, focused, minimized, maximized, fullscreen, bounds: { displayId, x, y, width, height } };
+}
+export async function openWindow(options: WindowOpenOptions): Promise<WindowInfo> {
+  validateOptions(options, Platform.OS, true);
+  // Optional undefined fields may be omitted; props have already undergone strict JSON validation.
+  const snapshot = JSON.parse(JSON.stringify(options)) as WindowOpenOptions;
+  if (snapshot.kind === "overlay") Object.assign(snapshot, { titleBarStyle: "borderless", transparent: true, hasShadow: false, alwaysOnTop: true, resizable: false, minimizable: false, ...snapshot });
+  if (Platform.OS === "macos") {
+    if (snapshot.kind === "overlay" && options.alwaysOnTop === undefined && options.macos?.level === undefined) {
+      snapshot.macos = { ...snapshot.macos, level: "status" };
+      delete snapshot.alwaysOnTop;
+    }
+    await createMacOSWindow(snapshot);
+    try {
+      const info = await windowCall("completeOpen", snapshot, isInfo);
+      // Common chrome is applied first; explicit AppKit groups own their corresponding fields.
+      if (!snapshot.macos) return publicInfo(info);
+      await updateMacOSWindow(snapshot.id, snapshot.macos);
+      // The window now exists: reflect the applied chrome, but a transient read-back
+      // failure must not discard a window that opened successfully, so fall back to info.
+      try { return await getWindow(snapshot.id); } catch { return publicInfo(info); }
+    } catch (cause) {
+      try { await windowCommand("discard", { id: snapshot.id }); }
+      catch (cleanup) { throw new SparkError("E_NATIVE", "Window opening and cleanup both failed", { cause: new AggregateError([cause, cleanup]) }); }
+      throw cause;
+    }
+  }
+  return publicInfo(await windowCall("open", snapshot, isInfo));
 }
-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);
+export async function getWindow(id: string): Promise<WindowInfo> { windowId(id); return publicInfo(await windowCall("info", { id }, isInfo)); }
+export async function listWindows(): Promise<WindowInfo[]> { return (await windowCall("list", {}, (value): value is NativeWindowInfo[] => Array.isArray(value) && value.every(isInfo))).map(publicInfo); }
+export async function getDisplays(): Promise<DisplayInfo[]> { return getNativeDisplays(); }
+/** Pointer position in Spark's coordinate vocabulary: logical units relative to the containing display's top-left corner. */
+export async function getCursorPoint(): Promise<CursorPoint> { return windowCall("cursorPoint", {}, (value): value is CursorPoint => record(value) && typeof value.displayId === "string" && Number.isFinite(value.x) && Number.isFinite(value.y)); }
+export async function setWindowOptions(id: string, options: WindowUpdateOptions): Promise<void> {
+  windowId(id); validateOptions(options, Platform.OS, false);
+  const snapshot = JSON.parse(JSON.stringify(options)) as WindowUpdateOptions;
+  if (!snapshot.macos || Object.keys(snapshot).some(key => key !== "macos")) {
+    await windowCommand("options", { id, options: snapshot });
   }
-  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);
+  if (snapshot.macos) await updateMacOSWindow(id, snapshot.macos);
 }
-export function setWindowOptions(windowId: string, options: WindowStyle) {
-  validateWindow(options);
-  if (Platform.OS === "windows") validateWindowsWindowOptions(options);
-  return call("options", { id: id(windowId), options });
+/** Portable frame change. Animated moves are macOS-only: pass `macos.durationMs` and the call rejects on Windows rather than ignoring the request. */
+export async function setWindowBounds(id: string, value: WindowBounds, options: SetWindowBoundsOptions = {}): Promise<void> {
+  windowId(id); bounds(value); object(options, "bounds options"); keys(options, ["macos"]);
+  if (options.macos !== undefined) {
+    if (Platform.OS !== "macos") throw new SparkError("E_UNSUPPORTED_OPTION", "macos bounds options require macOS");
+    const macos = options.macos; object(macos, "macos"); keys(macos, ["durationMs"]);
+    if (macos.durationMs !== undefined) number(macos.durationMs, "durationMs", 0, 60000);
+    await windowCommand("bounds", { id, bounds: value, durationMs: macos.durationMs ?? 0 });
+    return;
+  }
+  await windowCommand("bounds", { id, bounds: value });
+}
+export async function showWindow(id: string, options: ShowWindowOptions = {}): Promise<void> {
+  windowId(id); object(options, "show options"); keys(options, ["focus"]);
+  if (options.focus !== undefined && typeof options.focus !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "focus must be boolean");
+  await windowCommand("show", { id, focus: options.focus ?? true });
+}
+export async function centerWindow(id: string, options: CenterWindowOptions = {}): Promise<void> {
+  windowId(id); object(options, "center options"); keys(options, ["displayId"]);
+  if (options.displayId !== undefined) text(options.displayId, "display ID", false);
+  await windowCommand("center", { id, ...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 async function hideWindow(id: string): Promise<void> { windowId(id); await windowCommand("hide", { id }); }
+export async function minimizeWindow(id: string): Promise<void> { windowId(id); await windowCommand("minimize", { id }); }
+export async function maximizeWindow(id: string): Promise<void> { windowId(id); await windowCommand("maximize", { id }); }
+export async function unmaximizeWindow(id: string): Promise<void> { windowId(id); await windowCommand("unmaximize", { id }); }
+export async function setWindowFullscreen(id: string, enabled: boolean): Promise<void> {
+  windowId(id); if (typeof enabled !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "fullscreen must be boolean");
+  await windowCommand("fullscreen", { id, enabled });
+}
+const closing = new Map<string, Promise<CloseResult>>();
+export async function closeWindow(id: string): Promise<CloseResult> {
+  windowId(id);
+  let pending = closing.get(id);
+  if (!pending) {
+    pending = windowCall("close", { id }, (value): value is CloseResult => record(value) && (value.closed === true || (value.closed === false && value.reason === "vetoed"))).finally(() => closing.delete(id));
+    closing.set(id, pending);
+  }
+  return pending;
 }
-export function onWindowEvent(listener: (event: WindowEvent) => void) {
-  return onDesktopEvent(event => { if (typeof event.windowId === "string") listener(event as WindowEvent); });
+export interface WindowListenerOptions { onError?: (error: SparkError) => void }
+function report(options: WindowListenerOptions, cause: unknown) { try { (options.onError ?? console.error)(nativeError(cause)); } catch (error) { console.error(error); } }
+/** Registration acknowledges the live native instance. Removal stops callbacks immediately. */
+export async function addWindowListener<K extends keyof WindowEventMap>(id: string, type: K, listener: (event: WindowEventMap[K]) => void, options: WindowListenerOptions = {}): Promise<AsyncRegistration> {
+  windowId(id); object(options, "listener options"); keys(options, ["onError"]);
+  if (!["focusChanged", "boundsChanged", "visibilityChanged", "fullscreenChanged", "closed"].includes(type) || typeof listener !== "function" || (options.onError !== undefined && typeof options.onError !== "function")) throw new SparkError("E_INVALID_ARGUMENT", "Invalid window listener");
+  return subscribeToWindowInstance(id, event => {
+    if (event.type !== type) return;
+    const valid = type === "closed" || (type === "boundsChanged" ? isBounds(event.bounds) : typeof event[type === "focusChanged" ? "focused" : type === "visibilityChanged" ? "visible" : "fullscreen"] === "boolean");
+    if (!valid) { report(options, new SparkError("E_INVALID_DATA", "Malformed window event")); return; }
+    const payload = { windowId: id, ...(type === "boundsChanged" ? { bounds: event.bounds } : type === "focusChanged" ? { focused: event.focused } : type === "visibilityChanged" ? { visible: event.visible } : type === "fullscreenChanged" ? { fullscreen: event.fullscreen } : {}) };
+    try { listener(payload as WindowEventMap[K]); } catch (cause) { report(options, cause); }
+  }, [type]);
 }
-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; });
+const guards = new Map<string, AsyncRegistration>();
+const creatingGuards = new Set<string>();
+const orphanGuards = new Map<string, AsyncRegistration>();
+let guardSequence = 0;
+/** Each window accepts one close guard; a second registration rejects E_BUSY until the first is removed. Removal is idempotent. */
+export async function beforeWindowClose(id: string, handler: () => boolean | Promise<boolean>, options: WindowListenerOptions = {}): Promise<AsyncRegistration> {
+  windowId(id); object(options, "guard options"); keys(options, ["onError"]);
+  if (typeof handler !== "function" || (options.onError !== undefined && typeof options.onError !== "function")) throw new SparkError("E_INVALID_ARGUMENT", "Expected window close callbacks");
+  if (orphanGuards.has(id)) { await orphanGuards.get(id)!.remove(); orphanGuards.delete(id); }
+  if (guards.has(id) || creatingGuards.has(id)) throw new SparkError("E_BUSY", "Window already has a close guard");
+  creatingGuards.add(id);
+  const guardId = `close-${Date.now()}-${++guardSequence}`;
+  let stopped = false, instance: string | undefined, request: number | undefined, latestRequest = 0;
+  let subscription: ReturnType<typeof onDesktopEvent>;
+  try { subscription = onDesktopEvent(event => {
+    if (stopped || event.windowId !== id || event.instanceId !== instance) return;
+    if (event.type === "closed") { stopped = true; subscription.remove(); guards.delete(id); return; }
+    if (event.guardId !== guardId) return;
+    if (event.type === "closeGuardTimeout") { request = undefined; report(options, new SparkError("E_TIMEOUT", "Window close guard exceeded 30 seconds")); return; }
+    if (event.type !== "beforeClose" || !Number.isSafeInteger(event.requestId) || (event.requestId as number) <= latestRequest) return;
+    const current = latestRequest = request = event.requestId as number;
+    void Promise.resolve().then(() => stopped ? false : handler()).catch(cause => { report(options, cause); return false; }).then(async allow => {
+      if (stopped || request !== current) return;
+      await windowCommand("replyClose", { id, instanceId: instance, guardId, requestId: current, allow: allow === true });
+    }).catch(cause => report(options, cause)).finally(() => { if (request === current) request = undefined; });
+  }, { types: ["closed", "beforeClose", "closeGuardTimeout"], target: { field: "windowId", value: id } }); } catch (cause) { creatingGuards.delete(id); throw cause; }
+  const registration = asyncRegistration(() => { stopped = true; subscription.remove(); }, async () => {
+    try { if (instance) await windowCommand("closeGuard", { id, instanceId: instance, guardId, enabled: false }); }
+    catch (cause) { if (nativeError(cause).code !== "E_NOT_FOUND") throw cause; }
+    if (guards.get(id) === registration) guards.delete(id);
   });
-  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; }
-  } };
+  try {
+    instance = (await windowCall("observe", { id }, isInfo)).instanceId;
+    await windowCommand("closeGuard", { id, instanceId: instance, guardId, enabled: true });
+    if (!stopped) guards.set(id, registration); return registration;
+  } catch (cause) {
+    try { await registration.remove(); } catch (cleanup) { orphanGuards.set(id, registration); report(options, cleanup); }
+    throw cause;
+  } finally { creatingGuards.delete(id); }
 }

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

@@ -0,0 +1,17 @@
+import { parseNativeResult } from "@legendapp/spark-desktop-app/src/contracts";
+import { macosNative } from "./macos-adapter";
+export interface StartupTiming {
+  clockOffsetMs?: number;
+  startTime?: number;
+  endTime?: number;
+  initializeRuntimeStart?: number;
+  initializeRuntimeEnd?: number;
+  executeJavaScriptBundleEntryPointStart?: number;
+  executeJavaScriptBundleEntryPointEnd?: number;
+  mainWindowFirstVisibleTime?: number;
+  mainWindowReactRootAttachedTime?: number;
+}
+/** Native monotonic millisecond markers; clockOffsetMs maps them to wall-clock time. */
+export function getStartupTiming(): StartupTiming {
+  return parseNativeResult(macosNative().getReactNativeStartupTimingJson(), (value): value is StartupTiming => !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every(marker => typeof marker === "number" && Number.isFinite(marker)));
+}

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

@@ -1 +1,3 @@
-export * from "./api";
+export { getWindowAvailability, openWindow, getWindow, listWindows, getDisplays, getCursorPoint, setWindowOptions, setWindowBounds, showWindow, hideWindow, closeWindow, minimizeWindow, maximizeWindow, unmaximizeWindow, setWindowFullscreen, centerWindow, addWindowListener, beforeWindowClose, type WindowListenerOptions, type AsyncRegistration } from "./api";
+export type * from "./types";
+export * from "./windows";

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

@@ -1 +1,3 @@
-export * from "./api";
+export { getWindowAvailability, openWindow, getWindow, listWindows, getDisplays, setWindowOptions, setWindowBounds, showWindow, hideWindow, closeWindow, minimizeWindow, maximizeWindow, unmaximizeWindow, setWindowFullscreen, centerWindow, addWindowListener, beforeWindowClose, type WindowListenerOptions, type AsyncRegistration } from "./api";
+export type * from "./types";
+export * from "./windows";

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

@@ -0,0 +1,53 @@
+import { Platform } from "react-native";
+import { SparkError, invokeNative, parseNativeResult } from "@legendapp/spark-desktop-app/src/contracts";
+import { menuItems } from "@legendapp/spark-desktop-app/src/contracts/menu";
+import Native from "./window-manager/NativeWindowManager";
+import type { MacOSWindowOptions, WindowOpenOptions } from "./types";
+export function macosNative() {
+  if (Platform.OS !== "macos") throw new SparkError("E_UNSUPPORTED_PLATFORM", "This operation requires macOS");
+  if (!Native) throw new SparkError("E_MODULE_UNAVAILABLE", "The macOS window module is unavailable");
+  return Native;
+}
+export async function macosCommand(operation: () => Promise<string>): Promise<void> {
+  const result = parseNativeResult(await invokeNative(operation), (value): value is { success: boolean; message?: string } => !!value && typeof value === "object" && typeof (value as any).success === "boolean");
+  if (!result.success) throw new SparkError("E_NATIVE", result.message ?? "macOS window operation failed");
+}
+export function macosOptions(options: MacOSWindowOptions | undefined): Record<string, unknown> {
+  if (!options) return {};
+  const result: Record<string, unknown> = {}, style: Record<string, unknown> = {};
+  if (options.representedUri !== undefined) result.representedURL = options.representedUri;
+  if (options.restoreOnLaunch !== undefined) result.restoreOnLaunch = options.restoreOnLaunch;
+  if (options.startupSplitView !== undefined) style.startupSplitView = options.startupSplitView;
+  if (options.level !== undefined) {
+    const names = { normal: "NORMAL", floating: "FLOATING", modalPanel: "MODAL_PANEL", mainMenu: "MAIN_MENU", status: "STATUS", screenSaver: "SCREEN_SAVER" };
+    const constants = parseNativeResult(macosNative().getConstantsJson(), (value): value is Record<string, number> => !!value && typeof value === "object");
+    const value = constants[`WINDOW_LEVEL_${names[options.level]}`];
+    if (!Number.isFinite(value)) throw new SparkError("E_INVALID_DATA", "Missing native window level constant");
+    result.level = value;
+  }
+  if (options.panelStyle !== undefined) style.panelStyle = options.panelStyle;
+  const title = options.titleBar;
+  if (title) {
+    const fields = { contentLayout: "contentLayoutMode", transparent: "titlebarAppearsTransparent", titleVisibility: "titleVisibility", separator: "titlebarSeparatorStyle", material: "titlebarMaterial", blendingMode: "titlebarMaterialBlendingMode", materialState: "titlebarMaterialState", trafficLights: "trafficLights" } as const;
+    for (const [key, target] of Object.entries(fields)) if (title[key as keyof typeof fields] !== undefined) style[target] = title[key as keyof typeof fields];
+    if (title.controls) style.titlebarControls = title.controls.map(({ symbol, disabled, ...control }) => ({ ...control, type: "button", enabled: !disabled, systemImageName: symbol }));
+  }
+  if (options.toolbar) {
+    if (options.toolbar.visible !== undefined) style.hasToolbar = options.toolbar.visible;
+    if (options.toolbar.style !== undefined) style.toolbarStyle = options.toolbar.style;
+    if (options.toolbar.items) style.toolbarItems = options.toolbar.items.map(item => {
+      const { type, ...common } = item;
+      if (type === "segmented") { const value = item as Extract<typeof item, { type: "segmented" }>; return { ...common, type, selectedValue: value.value, segments: value.segments.map(({ symbol, ...segment }) => ({ ...segment, systemImageName: symbol })) }; }
+      if (type === "menu") { const { items, ...value } = item as Extract<typeof item, { type: "menu" }>; return { ...value, type: "menuButton", enabled: !value.disabled, systemImageName: value.symbol, menuItems: menuItems(items, { types: ["action", "checkbox", "separator", "slider"], icons: ["symbol"] }, "macos") }; }
+      return { ...common, type, ...("disabled" in item ? { enabled: !item.disabled } : {}), ...("symbol" in item ? { systemImageName: item.symbol } : {}) };
+    });
+  }
+  result.windowStyle = style;
+  return result;
+}
+export async function createMacOSWindow(options: WindowOpenOptions): Promise<void> {
+  await macosCommand(() => macosNative().openWindow(JSON.stringify({ ...macosOptions(options.macos), identifier: options.id, moduleName: options.component, initialProperties: options.props ?? {}, title: options.title, deferOrderFront: true, sparkOverlay: options.kind === "overlay" })));
+}
+export async function updateMacOSWindow(id: string, options: MacOSWindowOptions): Promise<void> {
+  await macosCommand(() => macosNative().setWindowOptions(id, JSON.stringify(macosOptions(options))));
+}

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

@@ -0,0 +1,51 @@
+import { SparkError, nativeError, type AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+export type { AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+import { macosCommand, macosNative } from "./macos-adapter";
+import { subscribeToWindowInstance } from "./transport";
+import { type WindowListenerOptions } from "./api";
+import { keys, number, object, text, windowId } from "./validation";
+import type { MacOSWindowBlurOptions, MacOSWindowEvent } from "./types";
+export type { MacOSWindowBlurOptions, MacOSWindowEvent, MacOSToolbarItem, MacOSToolbarOptions, MenuAction } from "./types";
+/** Animated frame changes go through `setWindowBounds` from `/windows` with a `macos.durationMs` group, which rejects on Windows. */
+export async function setWindowBlur(id: string, options: MacOSWindowBlurOptions): Promise<void> {
+  const native = macosNative(); windowId(id); object(options, "blur options"); keys(options, ["radius", "durationMs"]);
+  number(options.radius, "radius", 0, 1000); if (options.durationMs !== undefined) number(options.durationMs, "durationMs", 0, 60000);
+  await macosCommand(() => native.setWindowBlur(id, options.radius, options.durationMs ?? 0));
+}
+export interface FocusToolbarSearchOptions { value?: string }
+export async function focusToolbarSearch(id: string, itemId: string, options: FocusToolbarSearchOptions = {}): Promise<void> {
+  const native = macosNative(); windowId(id); text(itemId, "toolbar item ID", false); object(options, "search options"); keys(options, ["value"]);
+  if (options.value !== undefined) text(options.value, "search value");
+  await macosCommand(() => native.focusToolbarSearchItem(id, itemId, options.value ?? null));
+}
+export async function setToolbarItemText(id: string, itemId: string, value: string): Promise<void> {
+  const native = macosNative(); windowId(id); text(itemId, "toolbar item ID", false); text(value, "toolbar text");
+  await macosCommand(() => native.setWindowToolbarItemText(id, itemId, value));
+}
+export async function addMacOSWindowListener(id: string, listener: (event: MacOSWindowEvent) => void, options: WindowListenerOptions = {}): Promise<AsyncRegistration> {
+  macosNative(); windowId(id); object(options, "listener options"); keys(options, ["onError"]);
+  if (typeof listener !== "function" || (options.onError !== undefined && typeof options.onError !== "function")) throw new SparkError("E_INVALID_ARGUMENT", "Expected window event callbacks");
+  return subscribeToWindowInstance(id, event => {
+    if (!["titleBarAction", "toolbarAction", "toolbarSelectionChanged", "toolbarSearchChanged", "toolbarSearchSubmitted", "toolbarMenuAction"].includes(event.type)) return;
+    const report = (cause: unknown) => { if (options.onError) options.onError(nativeError(cause)); else console.error(cause); };
+    const error = () => report(new SparkError("E_INVALID_DATA", "Malformed macOS window event"));
+    const base = { windowId: id, type: event.type };
+    let payload: unknown;
+    if (event.type === "titleBarAction") {
+      if (typeof event.controlId !== "string" || !event.controlId) return error();
+      payload = { ...base, controlId: event.controlId };
+    } else {
+      if (typeof event.itemId !== "string" || !event.itemId) return error();
+      if (event.type === "toolbarAction") payload = { ...base, itemId: event.itemId };
+      else if (event.type === "toolbarMenuAction") {
+        const action = event.action as any;
+        if (!action || typeof action.itemId !== "string" || !action.itemId || (action.type !== "action" && !(action.type === "valueChanged" && typeof action.value === "number" && Number.isFinite(action.value)))) return error();
+        payload = { ...base, itemId: event.itemId, action: action.type === "action" ? { type: "action", itemId: action.itemId } : { type: "valueChanged", itemId: action.itemId, value: action.value } };
+      } else {
+        if (typeof event.value !== "string" || (event.type !== "toolbarSelectionChanged" && typeof event.shiftKey !== "boolean")) return error();
+        payload = { ...base, itemId: event.itemId, value: event.value, ...(event.type !== "toolbarSelectionChanged" ? { shiftKey: event.shiftKey } : {}) };
+      }
+    }
+    try { listener(payload as MacOSWindowEvent); } catch (cause) { report(cause); }
+  }, ["titleBarAction", "toolbarAction", "toolbarSelectionChanged", "toolbarSearchChanged", "toolbarSearchSubmitted", "toolbarMenuAction"]);
+}

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

@@ -0,0 +1,41 @@
+import { Platform } from "react-native";
+import { SparkError, asyncRegistration, invokeNative, parseNativeResult, type AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+import { onDesktopEvent, type DesktopEvent } from "@legendapp/spark-desktop-app/src/events";
+import Native from "./NativeDesktopWindowManager";
+import { windowId } from "./validation";
+import type { DisplayInfo, WindowBounds, WindowInfo } from "./types";
+
+/** Internal native transport shared by the public window API and the macOS adapter. Not part of any public entry point. */
+export const record = (value: unknown): value is Record<string, any> => !!value && typeof value === "object" && !Array.isArray(value);
+export const finite = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
+export const isSize = (value: unknown) => record(value) && finite(value.width) && value.width > 0 && finite(value.height) && value.height > 0;
+export const isBounds = (value: unknown): value is WindowBounds => record(value) && isSize(value) && finite(value.x) && finite(value.y) && typeof value.displayId === "string" && !!value.displayId;
+export interface NativeWindowInfo extends WindowInfo { instanceId: string }
+export const isInfo = (value: unknown): value is NativeWindowInfo => record(value) && typeof value.id === "string" && typeof value.instanceId === "string" && !!value.instanceId && ["window", "overlay"].includes(value.kind) && typeof value.title === "string" && (value.parentId === null || typeof value.parentId === "string") && [value.modal, value.visible, value.focused, value.minimized, value.maximized, value.fullscreen].every(flag => typeof flag === "boolean") && isBounds(value.bounds);
+
+export async function windowCall<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", "Windows require a desktop host");
+  if (!Native) throw new SparkError("E_MODULE_UNAVAILABLE", "The window module is unavailable");
+  const native = Native;
+  return parseNativeResult(await invokeNative(() => native.call(method, JSON.stringify(args))), validate);
+}
+export async function windowCommand(method: string, args: object): Promise<void> { await windowCall(method, args, (value): value is null => value === null); }
+/** Internal lifetime binding shared by ordinary and AppKit event subscriptions. */
+export async function subscribeToWindowInstance(id: string, listener: (event: DesktopEvent) => void, types: readonly string[] = ["focusChanged", "boundsChanged", "visibilityChanged", "fullscreenChanged"]): Promise<AsyncRegistration> {
+  windowId(id);
+  let instance: string | undefined, stopped = false;
+  const buffered: DesktopEvent[] = [];
+  const consume = (event: DesktopEvent) => {
+    if (stopped || event.windowId !== id) return;
+    if (!instance) { buffered.push(event); return; }
+    if (event.instanceId !== instance) return;
+    try { listener(event); } finally { if (event.type === "closed") { stopped = true; subscription.remove(); } }
+  };
+  const subscription = onDesktopEvent(consume, { types: [...types, "closed"], target: { field: "windowId", value: id } });
+  try { instance = (await windowCall("observe", { id }, isInfo)).instanceId; buffered.splice(0).forEach(consume); }
+  catch (cause) { stopped = true; subscription.remove(); throw cause; }
+  return asyncRegistration(() => { stopped = true; subscription.remove(); }, async () => {});
+}
+export async function getNativeDisplays(): Promise<DisplayInfo[]> {
+  return windowCall("displays", {}, (value): value is DisplayInfo[] => Array.isArray(value) && value.length > 0 && value.every(item => record(item) && typeof item.id === "string" && !!item.id && (item.persistentId === null || typeof item.persistentId === "string") && typeof item.name === "string" && typeof item.primary === "boolean" && isSize(item.size) && isSize(item.workArea) && finite(item.workArea.x) && finite(item.workArea.y) && finite(item.scaleFactor) && item.scaleFactor > 0) && value.filter(item => item.primary).length === 1 && new Set(value.map(item => item.id)).size === value.length);
+}