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

package/vendor/node_modules/@legendapp/spark-ui/src/types.ts

@@ -1,28 +1,39 @@
+import type { Ref } from "react";
 import type { StyleProp, ViewStyle } from "react-native";
-
+import type { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+/** A layout-only ref; backend objects and native control methods stay internal. */
+export interface ControlRef { measureInWindow(callback: (x: number, y: number, width: number, height: number) => void): void }
+export interface ControlProps {
+  disabled?: boolean;
+  accessibilityLabel?: string;
+  style?: StyleProp<ViewStyle>;
+  testID?: string;
+  ref?: Ref<ControlRef>;
+  onError?: (error: SparkError) => void;
+}
 /** A native text button. Layout styles affect its frame, not OS-managed chrome. */
-export type ButtonProps = {
+export interface ButtonProps extends ControlProps {
   children: string;
   onPress?: () => void;
-  disabled?: boolean;
   variant?: "default" | "bordered" | "borderless";
-  style?: StyleProp<ViewStyle>;
-  testID?: string;
-};
-
-/** Uncontrolled single-line input. defaultValue is read once per mount. */
-export type TextInputProps = {
+}
+export interface ControlledTextInputProps extends ControlProps {
+  value: string;
+  defaultValue?: never;
+  onChangeText?: (text: string) => void;
+}
+export interface UncontrolledTextInputProps extends ControlProps {
+  value?: never;
+  /** Read only on mount. Remount to reset an uncontrolled input. */
   defaultValue?: string;
   onChangeText?: (text: string) => void;
-  accessibilityLabel?: string;
-  style?: StyleProp<ViewStyle>;
-  testID?: string;
-};
-export type SelectProps = {
-  options: readonly { label: string; value: string }[];
+}
+export type TextInputProps = ControlledTextInputProps | UncontrolledTextInputProps;
+export interface SelectOption { label: string; value: string }
+export interface SelectProps extends ControlProps {
+  options: readonly SelectOption[];
   value: string;
   onValueChange: (value: string) => void;
-  accessibilityLabel?: string;
-  style?: StyleProp<ViewStyle>;
-  testID?: string;
-};
+}
+export interface SegmentedControlProps extends SelectProps {}
+export type ControlKind = "button" | "text-input" | "select" | "segmented-control";

package/vendor/node_modules/@legendapp/spark-ui/uniwind.ts

@@ -1,8 +1,10 @@
 import { withUniwind } from "uniwind";
-import { Button as NativeButton, TextInput as NativeTextInput, Select as NativeSelect } from "./src/index";
+import { Button as NativeButton, TextInput as NativeTextInput, Select as NativeSelect, SegmentedControl as NativeSegmentedControl } from "./src/index";
 
 // Optional, module-level bindings preserve each platform's native implementation.
 // className maps to the existing layout style; explicit style wins on conflicts.
 export const Button = withUniwind(NativeButton);
 export const TextInput = withUniwind(NativeTextInput);
 export const Select = withUniwind(NativeSelect);
+
+export const SegmentedControl = withUniwind(NativeSegmentedControl);

package/vendor/node_modules/@legendapp/spark-ui/uniwind.web.ts

@@ -1,7 +1,7 @@
 import { createElement, type ComponentType } from "react";
 import type { StyleProp, ViewStyle } from "react-native";
 import { useResolveClassNames } from "uniwind";
-import { Button as NativeButton, TextInput as NativeTextInput, Select as NativeSelect } from "./src/index";
+import { Button as NativeButton, TextInput as NativeTextInput, Select as NativeSelect, SegmentedControl as NativeSegmentedControl } from "./src/index";
 
 function withSparkClasses<Props extends { style?: StyleProp<ViewStyle> }>(Component: ComponentType<Props>) {
   return function UniwindControl({ className = "", style, ...props }: Props & { className?: string }) {
@@ -15,3 +15,5 @@ function withSparkClasses<Props extends { style?: StyleProp<ViewStyle> }>(Compon
 export const Button = withSparkClasses(NativeButton);
 export const TextInput = withSparkClasses(NativeTextInput);
 export const Select = withSparkClasses(NativeSelect);
+
+export const SegmentedControl = withSparkClasses(NativeSegmentedControl);

package/vendor/node_modules/@legendapp/spark-ui/windows/SparkUI/SparkUI.h

@@ -16,18 +16,17 @@ namespace React = Microsoft::ReactNative;
 namespace Composition = Microsoft::ReactNative::Composition;
 namespace Xaml = Microsoft::UI::Xaml;
 namespace Json = Windows::Data::Json;
-REACT_MODULE(SparkUIAvailability, L"NativeSparkUI")
-struct SparkUIAvailability {
-  REACT_SYNC_METHOD(isAvailable)
-  bool isAvailable() noexcept { return true; }
-};
 struct Props : implements<Props, React::IComponentProps> {
   React::ViewProps view{nullptr};
-  std::string title, defaultText, itemsJson = "[]", value, variant = "default";
-  bool disabled = false;
+  std::string title, defaultText, text, itemsJson = "[]", value, variant = "default";
+  bool disabled = false, controlled = false;
+  int32_t eventCount = 0;
   void SetProp(uint32_t, hstring const &name, React::IJSValueReader const &reader) noexcept {
     if (name == L"title") React::ReadValue(reader, title);
     else if (name == L"defaultText") React::ReadValue(reader, defaultText);
+    else if (name == L"text") React::ReadValue(reader, text);
+    else if (name == L"controlled") React::ReadValue(reader, controlled);
+    else if (name == L"eventCount") React::ReadValue(reader, eventCount);
     else if (name == L"itemsJson") React::ReadValue(reader, itemsJson);
     else if (name == L"value") React::ReadValue(reader, value);
     else if (name == L"variant") React::ReadValue(reader, variant);
@@ -56,10 +55,13 @@ struct Control : implements<Control, Windows::Foundation::IInspectable> {
   std::string kind, failure, items;
   std::vector<std::string> values;
   bool initialized = false, updating = false;
+  int32_t eventCount = 0;
   void Emit(hstring const &name, std::string const &key = "", std::string const &value = "") {
-    if (emitter) emitter.DispatchEvent(name, [key, value](React::IJSValueWriter const &writer) {
+    const auto count = eventCount;
+    if (emitter) emitter.DispatchEvent(name, [key, value, name, count](React::IJSValueWriter const &writer) {
       writer.WriteObjectBegin();
       if (!key.empty()) { writer.WritePropertyName(to_hstring(key)); writer.WriteString(to_hstring(value)); }
+      if (name == L"textChange") { writer.WritePropertyName(L"eventCount"); writer.WriteInt64(count); }
       writer.WriteObjectEnd();
     });
   }
@@ -78,7 +80,7 @@ struct Control : implements<Control, Windows::Foundation::IInspectable> {
       } else if (kind == "TextInput") {
         Xaml::Controls::TextBox input;
         input.TextChanged([weak](auto const &sender, auto const &) {
-          if (auto self = weak.get(); self && !self->updating) self->Emit(L"textChange", "text", to_string(sender.template as<Xaml::Controls::TextBox>().Text()));
+          if (auto self = weak.get(); self && !self->updating && self->control.IsEnabled()) { ++self->eventCount; self->Emit(L"textChange", "text", to_string(sender.template as<Xaml::Controls::TextBox>().Text())); }
         });
         control = input;
       } else {
@@ -113,14 +115,16 @@ struct Control : implements<Control, Windows::Foundation::IInspectable> {
       updating = true;
       control.IsEnabled(!props.disabled);
       Xaml::Automation::AutomationProperties::SetAutomationId(control, props.view.TestId());
-      Xaml::Automation::AutomationProperties::SetName(control, kind == "Button" ? to_hstring(props.title) : props.view.AccessibilityLabel());
+      Xaml::Automation::AutomationProperties::SetName(control, props.view.AccessibilityLabel().empty() && kind == "Button" ? to_hstring(props.title) : props.view.AccessibilityLabel());
       if (kind == "Button") {
         auto button = control.as<Xaml::Controls::Button>();
         button.Content(box_value(to_hstring(props.title)));
         // WinUI owns hover, pressed, keyboard, disabled, and accessibility states.
         button.BorderThickness(props.variant == "borderless" ? Xaml::Thickness{0, 0, 0, 0} : Xaml::Thickness{1, 1, 1, 1});
       } else if (kind == "TextInput") {
-        if (!initialized) control.as<Xaml::Controls::TextBox>().Text(to_hstring(props.defaultText));
+        auto input = control.as<Xaml::Controls::TextBox>();
+        if (!initialized) input.Text(to_hstring(props.defaultText));
+        if (props.controlled && props.eventCount >= eventCount && input.Text() != to_hstring(props.text)) input.Text(to_hstring(props.text));
       } else {
         auto select = control.as<Xaml::Controls::ComboBox>();
         if (items != props.itemsJson) {
@@ -153,6 +157,7 @@ inline void RegisterControls(React::IReactPackageBuilder const &package) {
         if (previous) {
           auto old = get_self<Props>(previous);
           props->title = old->title; props->defaultText = old->defaultText; props->itemsJson = old->itemsJson;
+          props->text = old->text; props->controlled = old->controlled; props->eventCount = old->eventCount;
           props->value = old->value; props->variant = old->variant; props->disabled = old->disabled;
         }
         props->view = view; return props.as<React::IComponentProps>();

package/vendor/node_modules/@legendapp/spark-updates/macos/RNDesktopUpdates.mm

@@ -22,7 +22,7 @@ static NSString *UnavailableReason(void) {
 + (instancetype)shared { static SparkUpdater *updater; static dispatch_once_t once; dispatch_once(&once, ^{ updater = [SparkUpdater new]; }); return updater; }
 - (NSDictionary *)status {
   NSString *reason = UnavailableReason();
-  NSMutableDictionary *result = [@{ @"available": @(!reason), @"started": @(self.started), @"canCheck": @(self.started && self.controller.updater.canCheckForUpdates), @"automaticallyChecks": @(self.started && self.controller.updater.automaticallyChecksForUpdates) } mutableCopy];
+  NSMutableDictionary *result = [@{ @"available": @(!reason), @"started": @(self.started), @"canCheck": @(self.started && self.controller.updater.canCheckForUpdates), @"automaticallyChecks": @(self.started && self.controller.updater.automaticallyChecksForUpdates), @"checkIntervalSeconds": reason ? NSNull.null : @(self.started ? self.controller.updater.updateCheckInterval : 3600) } mutableCopy];
   if (reason) result[@"reason"] = reason;
   if (!reason) result[@"feedURL"] = [NSBundle.mainBundle objectForInfoDictionaryKey:@"SUFeedURL"];
   return result;
@@ -55,17 +55,30 @@ RCT_EXPORT_MODULE(NativeDesktopUpdates)
   [NSRunLoop.mainRunLoop performBlock:^{
     SparkUpdater *updater = [SparkUpdater shared];
     if ([method isEqual:@"status"]) { resolve(SparkJSON([updater status])); return; }
-    if (![@[@"start", @"check", @"automatic"] containsObject:method]) { SparkInvalid(reject, @"Unknown update operation"); return; }
+    if (![@[@"start", @"check", @"background", @"configure"] containsObject:method]) { SparkInvalid(reject, @"Unknown update operation"); return; }
+    NSDictionary *args = SparkArgs(json);
+    if ([method isEqual:@"configure"]) {
+      id enabled = args[@"automaticallyChecks"], interval = args[@"checkIntervalSeconds"];
+      if ((enabled && (![enabled isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)enabled) != CFBooleanGetTypeID())) ||
+          (interval && (![interval isKindOfClass:NSNumber.class] || CFGetTypeID((__bridge CFTypeRef)interval) == CFBooleanGetTypeID() || !isfinite([interval doubleValue]) || [interval doubleValue] <= 0))) {
+        SparkInvalid(reject, @"Invalid updater configuration"); return;
+      }
+    }
     NSString *reason = UnavailableReason();
-    if (reason) { reject(@"E_UPDATES_UNAVAILABLE", [@"Updates require a configured standalone release app; current state: " stringByAppendingString:reason], nil); return; }
+    if (reason) { reject(@"E_UNAVAILABLE", [@"Updates require a configured standalone release app; current state: " stringByAppendingString:reason], nil); return; }
     NSError *error = nil;
-    if (![updater start:&error]) { reject(@"E_UPDATES_START", error.localizedDescription ?: @"Could not start updater", error); return; }
+    if (![updater start:&error]) { reject(@"E_NATIVE", error.localizedDescription ?: @"Could not start updater", error); return; }
     if ([method isEqual:@"check"]) {
-      if (!updater.controller.updater.canCheckForUpdates) { reject(@"E_UPDATES_BUSY", @"An update session is already running", nil); return; }
+      if (!updater.controller.updater.canCheckForUpdates) { reject(@"E_BUSY", @"An update session is already running", nil); return; }
       [updater.controller checkForUpdates:nil]; resolve(@"null");
-    } else if ([method isEqual:@"automatic"]) {
-      updater.controller.updater.automaticallyChecksForUpdates = [SparkArgs(json)[@"enabled"] boolValue]; resolve(@"null");
-    } else resolve(SparkJSON([updater status]));
+    } else if ([method isEqual:@"background"]) {
+      if (!updater.controller.updater.canCheckForUpdates) { reject(@"E_BUSY", @"An update session is already running", nil); return; }
+      [updater.controller.updater checkForUpdatesInBackground]; resolve(@"null");
+    } else if ([method isEqual:@"configure"]) {
+      if (args[@"automaticallyChecks"]) updater.controller.updater.automaticallyChecksForUpdates = [args[@"automaticallyChecks"] boolValue];
+      if (args[@"checkIntervalSeconds"]) updater.controller.updater.updateCheckInterval = [args[@"checkIntervalSeconds"] doubleValue];
+      resolve(@"null");
+    } else resolve(@"null");
   }];
 }
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params { return std::make_shared<facebook::react::NativeDesktopUpdatesSpecJSI>(params); }

package/vendor/node_modules/@legendapp/spark-updates/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-updates",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.3",
   "license": "MIT",
   "main": "src/index.ts",
   "react-native": "src/index.ts",
@@ -38,7 +38,7 @@
     ]
   },
   "dependencies": {
-    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+    "@legendapp/spark-desktop-app": "0.0.1-next.3"
   },
   "private": true
 }

package/vendor/node_modules/@legendapp/spark-updates/src/NativeDesktopUpdates.ts

@@ -1,4 +1,5 @@
 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>("NativeDesktopUpdates");
+export interface Spec extends TurboModule {
+  call(method: string, args: string): Promise<string>; }
+export default TurboModuleRegistry.get<Spec>("NativeDesktopUpdates");

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

@@ -1,23 +1,79 @@
+import { Platform } from "react-native";
 import Native from "./NativeDesktopUpdates";
-import { onDesktopEvent } from "@legendapp/spark-desktop-app";
+import { onDesktopEvent } from "@legendapp/spark-desktop-app/src/events";
+import { SparkError, invokeNative, parseNativeResult, type Subscription } from "@legendapp/spark-desktop-app/src/contracts";
+export type { Subscription } from "@legendapp/spark-desktop-app/src/contracts";
 
+export type UpdateUnavailableReason = "unsupported-platform" | "missing-module" | "go" | "development" | "unconfigured";
 export type UpdateStatus = {
-  available: boolean;
-  reason?: "go" | "development" | "unconfigured";
+  available: true;
   started: boolean;
   canCheck: boolean;
   automaticallyChecks: boolean;
-  feedURL?: string;
+  checkIntervalSeconds: number;
+  feedURL: string;
+} | {
+  available: false;
+  reason: UpdateUnavailableReason;
+  started: false;
+  canCheck: false;
+  automaticallyChecks: false;
+  checkIntervalSeconds: null;
 };
-export type UpdateEvent = { type: "update"; state: "checking" | "available" | "notAvailable" | "downloading" | "downloaded" | "installing" | "error"; version?: string; message?: string };
-async function call<T = void>(method: string, args: object = {}): Promise<T> { return JSON.parse(await Native.call(method, JSON.stringify(args))) as T; }
-export const getUpdateStatus = () => call<UpdateStatus>("status");
-/** Start Sparkle's scheduler after the application is ready. Safe to call again. */
-export const startUpdates = () => call<UpdateStatus>("start");
-/** Opens Sparkle's standard check/download/install UI. Resolves when the check starts. */
-export const checkForUpdates = () => call("check");
-/** Change this only in response to the user's preference; Sparkle persists it. */
-export const setAutomaticUpdateChecks = (enabled: boolean) => call("automatic", { enabled });
-export function onUpdateEvent(listener: (event: UpdateEvent) => void) {
-  return onDesktopEvent(event => { if (event.type === "update") listener(event as UpdateEvent); });
+export interface UpdateConfiguration { automaticallyChecks?: boolean; checkIntervalSeconds?: number }
+export interface CheckForUpdatesOptions { mode?: "interactive" | "background" }
+export type UpdateEvent =
+  | { type: "update"; state: "checking" | "notAvailable" }
+  | { type: "update"; state: "available" | "downloading" | "downloaded" | "installing"; version: string }
+  | { type: "update"; state: "error"; message: string };
+function native() {
+  if (Platform.OS !== "macos") throw new SparkError("E_UNSUPPORTED_PLATFORM", "Native app updates require macOS");
+  if (!Native) throw new SparkError("E_MODULE_UNAVAILABLE", "Native app updater is not installed");
+  return Native;
+}
+const unavailable = (reason: UpdateUnavailableReason): UpdateStatus => ({ available: false, reason, started: false, canCheck: false, automaticallyChecks: false, checkIntervalSeconds: null });
+function validStatus(value: unknown): value is UpdateStatus {
+  if (!value || typeof value !== "object") return false;
+  const status = value as UpdateStatus;
+  if (status.available === false) return ["go", "development", "unconfigured"].includes(status.reason) && status.started === false && status.canCheck === false && status.automaticallyChecks === false && status.checkIntervalSeconds === null;
+  return status.available === true && typeof status.started === "boolean" && typeof status.canCheck === "boolean" && typeof status.automaticallyChecks === "boolean" && Number.isFinite(status.checkIntervalSeconds) && status.checkIntervalSeconds > 0 && typeof status.feedURL === "string" && status.feedURL.startsWith("https://");
+}
+async function command(method: string, args: object = {}): Promise<void> {
+  parseNativeResult(await invokeNative(() => native().call(method, JSON.stringify(args))), (value): value is null => value === null);
+}
+/** Querying never starts the updater. Missing modules and unsupported targets are reported. */
+export async function getUpdateStatus(): Promise<UpdateStatus> {
+  if (Platform.OS !== "macos") return unavailable("unsupported-platform");
+  if (!Native) return unavailable("missing-module");
+  return parseNativeResult(await invokeNative(() => native().call("status", "{}")), validStatus);
+}
+/** Start the scheduler after app readiness. Repeated starts are safe. */
+export async function startUpdates(): Promise<void> { await command("start"); }
+function options(value: unknown, keys: string[]) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new SparkError("E_INVALID_ARGUMENT", "Expected update options");
+  for (const key of Object.keys(value)) if (!keys.includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unsupported update option: ${key}`);
+}
+/** Resolves when initiated. Events describe progress, not the returned promise. */
+export async function checkForUpdates(config: CheckForUpdatesOptions = {}): Promise<void> {
+  options(config, ["mode"]);
+  const mode = config.mode ?? "interactive";
+  if (!["interactive", "background"].includes(mode)) throw new SparkError("E_INVALID_ARGUMENT", "Invalid update check mode");
+  await command(mode === "interactive" ? "check" : "background");
+}
+/** Omission keeps a preference unchanged. Sparkle persists the user's choices. */
+export async function configureUpdates(config: UpdateConfiguration): Promise<void> {
+  options(config, ["automaticallyChecks", "checkIntervalSeconds"]);
+  if (config.automaticallyChecks !== undefined && typeof config.automaticallyChecks !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "automaticallyChecks must be boolean");
+  if (config.checkIntervalSeconds !== undefined && (!Number.isFinite(config.checkIntervalSeconds) || config.checkIntervalSeconds <= 0)) throw new SparkError("E_INVALID_ARGUMENT", "Update interval must be positive finite seconds");
+  await command("configure", config);
+}
+export function onUpdateEvent(listener: (event: UpdateEvent) => void): Subscription {
+  if (typeof listener !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected an update listener");
+  native();
+  return onDesktopEvent(event => {
+    if (event.type !== "update" || typeof event.state !== "string") return;
+    const version = typeof event.version === "string", message = typeof event.message === "string";
+    const valid = ["checking", "notAvailable"].includes(event.state) || (["available", "downloading", "downloaded", "installing"].includes(event.state) && version) || (event.state === "error" && message);
+    if (valid) listener(event as unknown as UpdateEvent);
+  }, { types: ["update"] });
 }

package/vendor/node_modules/@legendapp/spark-webview/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-webview",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.3",
   "license": "MIT",
   "main": "src/index.ts",
   "react-native": "src/index.ts",
@@ -9,7 +9,7 @@
   ],
   "dependencies": {
     "react-native-webview": "16.0.0",
-    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+    "@legendapp/spark-desktop-app": "0.0.1-next.3"
   },
   "private": true
 }

package/vendor/node_modules/@legendapp/spark-webview/src/WebView.tsx

@@ -0,0 +1,11 @@
+import { forwardRef, useImperativeHandle, useRef } from "react";
+import { WebView as BackendWebView } from "react-native-webview";
+import { backendProps, webViewRef } from "./adapter";
+import type { WebViewProps, WebViewRef } from "./types";
+
+/** Spark-owned props, events and ref; backend-specific APIs remain private. */
+export const WebView = forwardRef<WebViewRef, WebViewProps>(function WebView(props, ref) {
+  const native = useRef<BackendWebView>(null);
+  useImperativeHandle(ref, () => webViewRef(() => native.current), []);
+  return <BackendWebView {...backendProps(props)} ref={native} />;
+});

package/vendor/node_modules/@legendapp/spark-webview/src/adapter.ts

@@ -0,0 +1,55 @@
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import type { WebViewProps as BackendProps } from "react-native-webview";
+import { viewPropKeys } from "./view-props";
+import type { ViewPropKey } from "./view-props";
+import type { WebViewProps, WebViewRef } from "./types";
+
+const ownedProps = new Set(["source", "javaScriptEnabled", "injectedJavaScript", "allowedOrigins", "onMessage", "onLoad", "onError", "onNavigationChange", "onNavigationRequest"]);
+/** React Native view props pass through; upstream WebView's specialized surface stays private. */
+const forwardedProps = new Set<string>(viewPropKeys);
+export function backendProps(props: WebViewProps): BackendProps {
+  for (const key of Object.keys(props)) {
+    if (!ownedProps.has(key) && !forwardedProps.has(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unsupported WebView prop: ${key}`);
+  }
+  const { source } = props;
+  if (!source || (typeof source.uri === "string") === (typeof source.html === "string")) {
+    throw new SparkError("E_INVALID_ARGUMENT", "WebView source must specify either uri or html");
+  }
+  const view: Record<string, unknown> = {};
+  for (const key of viewPropKeys) {
+    const value = props[key as ViewPropKey];
+    if (value !== undefined) view[key] = value;
+  }
+  return {
+    ...view,
+    source: typeof source.html === "string" ? { html: source.html, baseUrl: source.baseUri } : { uri: source.uri!, headers: source.headers },
+    javaScriptEnabled: props.javaScriptEnabled ?? true,
+    injectedJavaScript: props.injectedJavaScript,
+    originWhitelist: props.allowedOrigins ? [...props.allowedOrigins] : typeof source.html === "string" ? ["*"] : ["http://*", "https://*"],
+    onMessage: props.onMessage ? ({ nativeEvent: event }) => props.onMessage!({ data: event.data, uri: event.url }) : undefined,
+    onLoad: props.onLoad ? ({ nativeEvent: event }) => props.onLoad!({ uri: event.url }) : undefined,
+    onError: props.onError ? ({ nativeEvent: event }) => props.onError!({ type: "load", uri: event.url, code: event.code, message: event.description }) : undefined,
+    onHttpError: props.onError ? ({ nativeEvent: event }) => props.onError!({ type: "http", uri: event.url, status: event.statusCode, message: event.description }) : undefined,
+    onNavigationStateChange: props.onNavigationChange ? event => props.onNavigationChange!({ uri: event.url, title: event.title, loading: event.loading, canGoBack: event.canGoBack, canGoForward: event.canGoForward }) : undefined,
+    onShouldStartLoadWithRequest: props.onNavigationRequest ? event => props.onNavigationRequest!({ uri: event.url, mainFrame: typeof event.isTopFrame === "boolean" ? event.isTopFrame : null }) : undefined,
+  };
+}
+
+export function webViewRef(current: () => WebViewRef | null): WebViewRef {
+  function view() {
+    const value = current();
+    if (!value) throw new SparkError("E_CLOSED", "WebView is not mounted");
+    return value;
+  }
+  return {
+    reload: () => view().reload(), goBack: () => view().goBack(), goForward: () => view().goForward(),
+    postMessage(message) {
+      if (typeof message !== "string") throw new SparkError("E_INVALID_ARGUMENT", "WebView messages must be strings");
+      view().postMessage(message);
+    },
+    injectJavaScript(script) {
+      if (typeof script !== "string") throw new SparkError("E_INVALID_ARGUMENT", "WebView scripts must be strings");
+      view().injectJavaScript(script);
+    },
+  };
+}

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

@@ -1,2 +1,2 @@
-export { WebView } from "react-native-webview";
-export type { WebViewProps, WebViewMessageEvent, WebViewNavigation } from "react-native-webview";
+export { WebView } from "./WebView";
+export type { WebViewProps, WebViewRef, WebViewSource, WebViewMessageEvent, WebViewNavigation, WebViewNavigationRequest, WebViewErrorEvent } from "./types";

package/vendor/node_modules/@legendapp/spark-webview/src/types.ts

@@ -0,0 +1,32 @@
+import type { ViewProps } from "react-native";
+export type WebViewSource =
+  | { uri: string; headers?: Record<string, string>; html?: never; baseUri?: never }
+  | { html: string; baseUri?: string; uri?: never; headers?: never };
+export type WebViewMessageEvent = { data: string; uri: string };
+export type WebViewNavigation = { uri: string; title: string; loading: boolean; canGoBack: boolean; canGoForward: boolean };
+export type WebViewNavigationRequest = { uri: string; mainFrame: boolean | null };
+export type WebViewErrorEvent =
+  | { type: "load"; uri: string; code: number; message: string }
+  | { type: "http"; uri: string; status: number; message: string };
+/** React Native's view props are accepted; WebView-specific behavior is owned here. Children are not: the rendered content is the source document. */
+export interface WebViewProps extends Omit<ViewProps, "children"> {
+  source: WebViewSource;
+  javaScriptEnabled?: boolean;
+  /** Script executed after page load. Applies to trusted document content. */
+  injectedJavaScript?: string;
+  /** Origin patterns accepted by the current adapter; default is HTTP/HTTPS. Inline HTML permits all origins. */
+  allowedOrigins?: readonly string[];
+  onMessage?: (event: WebViewMessageEvent) => void;
+  onLoad?: (event: { uri: string }) => void;
+  onError?: (event: WebViewErrorEvent) => void;
+  onNavigationChange?: (event: WebViewNavigation) => void;
+  /** Synchronous native navigation decision where emitted; not a network security boundary. */
+  onNavigationRequest?: (event: WebViewNavigationRequest) => boolean;
+}
+export interface WebViewRef {
+  reload(): void;
+  goBack(): void;
+  goForward(): void;
+  postMessage(message: string): void;
+  injectJavaScript(script: string): void;
+}

package/vendor/node_modules/@legendapp/spark-webview/src/view-props.ts

@@ -0,0 +1,28 @@
+import type { ViewProps } from "react-native";
+
+/**
+ * React Native's own view props, forwarded to the backend view. `children` is omitted:
+ * a WebView renders a document, not React children. The `satisfies` clause makes the
+ * list fail to compile if it names something React Native does not accept.
+ */
+export const viewPropKeys = [
+  "accessibilityActions", "accessibilityElementsHidden", "accessibilityHint", "accessibilityIgnoresInvertColors",
+  "accessibilityLabel", "accessibilityLabelledBy", "accessibilityLanguage", "accessibilityLargeContentTitle",
+  "accessibilityLiveRegion", "accessibilityRespondsToUserInteraction", "accessibilityRole",
+  "accessibilityShowsLargeContentViewer", "accessibilityState", "accessibilityValue", "accessibilityViewIsModal",
+  "accessible", "aria-busy", "aria-checked", "aria-disabled", "aria-expanded", "aria-hidden", "aria-label",
+  "aria-labelledby", "aria-live", "aria-modal", "aria-selected", "aria-valuemax", "aria-valuemin", "aria-valuenow",
+  "aria-valuetext", "collapsable", "collapsableChildren", "focusable", "hasTVPreferredFocus", "hitSlop", "id",
+  "importantForAccessibility", "isTVSelectable", "nativeID", "needsOffscreenAlphaCompositing",
+  "onAccessibilityAction", "onAccessibilityEscape", "onAccessibilityTap", "onBlur", "onFocus", "onLayout",
+  "onMagicTap", "onMoveShouldSetResponder", "onMoveShouldSetResponderCapture", "onPointerCancel",
+  "onPointerCancelCapture", "onPointerDown", "onPointerDownCapture", "onPointerEnter", "onPointerEnterCapture",
+  "onPointerLeave", "onPointerLeaveCapture", "onPointerMove", "onPointerMoveCapture", "onPointerUp",
+  "onPointerUpCapture", "onResponderEnd", "onResponderGrant", "onResponderMove", "onResponderReject",
+  "onResponderRelease", "onResponderStart", "onResponderTerminate", "onResponderTerminationRequest",
+  "onStartShouldSetResponder", "onStartShouldSetResponderCapture", "onTouchCancel", "onTouchEnd",
+  "onTouchEndCapture", "onTouchMove", "onTouchStart", "pointerEvents", "removeClippedSubviews",
+  "renderToHardwareTextureAndroid", "role", "screenReaderFocusable", "shouldRasterizeIOS", "style", "tabIndex",
+  "testID", "tvParallaxMagnification", "tvParallaxShiftDistanceX", "tvParallaxShiftDistanceY", "tvParallaxTiltAngle",
+] as const satisfies readonly (keyof Omit<ViewProps, "children">)[];
+export type ViewPropKey = (typeof viewPropKeys)[number];

package/vendor/node_modules/@legendapp/spark-window-options/index.cjs

@@ -1,25 +1,62 @@
 const enums = {
   titleBarStyle: ["default", "overlay", "hidden", "borderless"],
   appearance: ["system", "light", "dark"],
-  material: ["none", "sidebar", "windowBackground", "hudWindow", "popover"],
 };
-const dimensions = ["width", "height", "minWidth", "minHeight", "maxWidth", "maxHeight"];
-const booleans = ["resizable", "closable", "minimizable", "alwaysOnTop", "transparent", "hasShadow", "trafficLights", "restoreFrame"];
+const booleans = ["resizable", "closable", "minimizable", "alwaysOnTop", "transparent", "hasShadow", "restoreBounds"];
+const dimension = { type: "number", minimum: 100, maximum: 20000 };
+const size = { type: "object", required: ["width", "height"], additionalProperties: false, properties: { width: dimension, height: dimension } };
+const materials = ["none", "sidebar", "windowBackground", "hudWindow", "popover"];
+const schema = {
+  type: "object", additionalProperties: false,
+  properties: {
+    size, minSize: { anyOf: [size, { type: "null" }] }, maxSize: { anyOf: [size, { type: "null" }] },
+    ...Object.fromEntries(booleans.map(key => [key, { type: "boolean" }])),
+    ...Object.fromEntries(Object.entries(enums).map(([key, values]) => [key, { enum: values }])),
+    title: { type: "string" }, backgroundColor: { type: "string", pattern: "^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$" },
+    macos: { type: "object", additionalProperties: false, properties: {
+      backgroundMaterial: { enum: materials },
+      titleBar: { type: "object", additionalProperties: false, properties: { trafficLights: { type: "boolean" } } },
+    } },
+  },
+};
+function object(value, allowed, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${name} must be an object`);
+  for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new Error(`Unknown ${name} option: ${key}`);
+}
 function validateWindow(options) {
-  if (!options || typeof options !== "object" || Array.isArray(options)) throw new Error("window must be an object");
-  const allowed = [...dimensions, ...booleans, ...Object.keys(enums), "title", "backgroundColor"];
-  for (const key of Object.keys(options)) if (!allowed.includes(key)) throw new Error(`Unknown window option: ${key}`);
-  for (const key of dimensions) if (options[key] !== undefined && (!Number.isFinite(options[key]) || options[key] < 100 || options[key] > 20000)) throw new Error(`${key} must be between 100 and 20000 points`);
-  for (const axis of ["Width", "Height"]) {
-    const min = options[`min${axis}`] ?? 100, max = options[`max${axis}`] ?? 20000;
-    if (min > max) throw new Error(`min${axis} exceeds max${axis}`);
-    const size = options[axis.toLowerCase()];
-    if (size !== undefined && (size < min || size > max)) throw new Error(`${axis.toLowerCase()} is outside its constraints`);
+  object(options, Object.keys(schema.properties), "window");
+  for (const key of ["size", "minSize", "maxSize"]) if (options[key] !== undefined && !(key !== "size" && options[key] === null)) {
+    object(options[key], ["width", "height"], key);
+    for (const axis of ["width", "height"]) if (!Number.isFinite(options[key][axis]) || options[key][axis] < 100 || options[key][axis] > 20000) throw new Error(`${key}.${axis} must be between 100 and 20000 logical units`);
+  }
+  for (const axis of ["width", "height"]) {
+    const min = options.minSize?.[axis] ?? 100, max = options.maxSize?.[axis] ?? 20000;
+    if (min > max) throw new Error(`minSize.${axis} exceeds maxSize.${axis}`);
+    if (options.size && (options.size[axis] < min || options.size[axis] > max)) throw new Error(`size.${axis} is outside its constraints`);
   }
   for (const key of booleans) if (options[key] !== undefined && typeof options[key] !== "boolean") throw new Error(`${key} must be a boolean`);
   for (const [key, values] of Object.entries(enums)) if (options[key] !== undefined && !values.includes(options[key])) throw new Error(`Invalid ${key}`);
   if (options.title !== undefined && typeof options.title !== "string") throw new Error("title must be a string");
-  if (options.backgroundColor !== undefined && !/^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/.test(options.backgroundColor)) throw new Error("backgroundColor must be #RRGGBB or #RRGGBBAA");
+  if (options.backgroundColor !== undefined && (typeof options.backgroundColor !== "string" || !new RegExp(schema.properties.backgroundColor.pattern).test(options.backgroundColor))) throw new Error("backgroundColor must be #RRGGBB or #RRGGBBAA");
+  if (options.macos !== undefined) {
+    object(options.macos, ["backgroundMaterial", "titleBar"], "macos");
+    if (options.macos.backgroundMaterial !== undefined && !materials.includes(options.macos.backgroundMaterial)) throw new Error("Invalid macos.backgroundMaterial");
+    if (options.macos.titleBar !== undefined) {
+      object(options.macos.titleBar, ["trafficLights"], "macos.titleBar");
+      if (options.macos.titleBar.trafficLights !== undefined && typeof options.macos.titleBar.trafficLights !== "boolean") throw new Error("trafficLights must be a boolean");
+    }
+  }
   return options;
 }
-module.exports = { validateWindow, dimensions, booleans, enums };
+// Private host transport. Consumers only author the grouped configuration above.
+function nativeWindowOptions(value) {
+  const { size, minSize, maxSize, restoreBounds, macos, ...result } = validateWindow(value);
+  for (const [prefix, dimensions] of [["", size], ["min", minSize], ["max", maxSize]]) if (dimensions) {
+    for (const axis of ["width", "height"]) result[prefix ? prefix + axis[0].toUpperCase() + axis.slice(1) : axis] = dimensions[axis];
+  }
+  if (restoreBounds !== undefined) result.restoreFrame = restoreBounds;
+  if (macos?.backgroundMaterial !== undefined) result.material = macos.backgroundMaterial;
+  if (macos?.titleBar?.trafficLights !== undefined) result.trafficLights = macos.titleBar.trafficLights;
+  return result;
+}
+module.exports = { validateWindow, nativeWindowOptions, schema };

package/vendor/node_modules/@legendapp/spark-window-options/index.d.ts

@@ -1,12 +1,25 @@
-export type WindowStyle = {
+export interface WindowSize { width: number; height: number }
+/** Initial outer frame dimensions in logical units, matching the runtime window API. */
+export interface WindowConfiguration {
   title?: string;
-  width?: number; height?: number;
-  minWidth?: number; minHeight?: number; maxWidth?: number; maxHeight?: number;
-  resizable?: boolean; closable?: boolean; minimizable?: boolean;
-  alwaysOnTop?: boolean; transparent?: boolean; hasShadow?: boolean; trafficLights?: boolean; restoreFrame?: boolean;
+  size?: WindowSize;
+  minSize?: WindowSize | null;
+  maxSize?: WindowSize | null;
+  resizable?: boolean;
+  closable?: boolean;
+  minimizable?: boolean;
+  alwaysOnTop?: boolean;
+  transparent?: boolean;
+  hasShadow?: boolean;
+  restoreBounds?: boolean;
   titleBarStyle?: "default" | "overlay" | "hidden" | "borderless";
   appearance?: "system" | "light" | "dark";
-  material?: "none" | "sidebar" | "windowBackground" | "hudWindow" | "popover";
   backgroundColor?: string;
-};
-export function validateWindow(options: unknown): WindowStyle;
+  macos?: {
+    backgroundMaterial?: "none" | "sidebar" | "windowBackground" | "hudWindow" | "popover";
+    titleBar?: { trafficLights?: boolean };
+  };
+}
+export function validateWindow(options: unknown): WindowConfiguration;
+export function nativeWindowOptions(options: unknown): Record<string, string | number | boolean>;
+export const schema: Record<string, unknown>;

package/vendor/node_modules/@legendapp/spark-window-options/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-window-options",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.3",
   "license": "MIT",
   "main": "index.cjs",
   "types": "index.d.ts",