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

package/vendor/node_modules/@legendapp/spark-ui/src/native-select/NativeSelectNativeComponent.ts

@@ -0,0 +1,17 @@
+import type { HostComponent, ViewProps } from "react-native";
+import { codegenNativeComponent } from "react-native";
+import type { DirectEventHandler, Int32 } from "react-native/Libraries/Types/CodegenTypes";
+
+export type NativeSelectChangeEvent = {
+  value: string;
+};
+
+export interface NativeProps extends ViewProps {
+  enabled?: boolean;
+  selectionRevision?: Int32;
+  itemsJson: string;
+  onValueChange?: DirectEventHandler<NativeSelectChangeEvent>;
+  value: string;
+}
+
+export default codegenNativeComponent<NativeProps>("NativeSelect") as HostComponent<NativeProps>;

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

@@ -1,7 +1,9 @@
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
 import type { SelectProps } from "./types";
-export function selectionIndex(options: SelectProps["options"], value: string) {
-  if (!options.length || new Set(options.map(option => option.value)).size !== options.length) throw new Error("Select options must be nonempty with unique values");
+export function selectionIndex(options: SelectProps["options"], value: string): number {
+  if (!Array.isArray(options) || !options.length || Array.from(options).some(option => !option || typeof option !== "object" || typeof option.label !== "string" || !option.label.length || typeof option.value !== "string") || new Set(options.map(option => option.value)).size !== options.length) throw new SparkError("E_INVALID_ARGUMENT", "Select options must have nonempty labels and unique string values");
+  for (const option of options) for (const key of Object.keys(option)) if (key !== "label" && key !== "value") throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown select option: ${key}`);
   const index = options.findIndex(option => option.value === value);
-  if (index < 0) throw new Error("Select value must match an option");
+  if (index < 0) throw new SparkError("E_INVALID_ARGUMENT", "Select value must match an option");
   return index;
 }

package/vendor/node_modules/@legendapp/spark-ui/src/sf-symbol/SFSymbolNativeComponent.ts

@@ -0,0 +1,13 @@
+import type { CodegenTypes, ColorValue, HostComponent, ViewProps } from "react-native";
+import { codegenNativeComponent } from "react-native";
+
+export interface NativeProps extends ViewProps {
+  name: string;
+  onSymbolError?: CodegenTypes.DirectEventHandler<Readonly<{ name: string; message: string }>>;
+  color?: ColorValue;
+  scale?: string;
+  size?: CodegenTypes.Double;
+  yOffset?: CodegenTypes.Double;
+}
+
+export default codegenNativeComponent<NativeProps>("SFSymbol") as HostComponent<NativeProps>;

package/vendor/node_modules/@legendapp/spark-ui/src/sf-symbol/index.tsx

@@ -0,0 +1,27 @@
+import { View, type ColorValue, type NativeSyntheticEvent } from "react-native";
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { useControl } from "../control";
+import { finite, identifier, macosViewAvailability, type SpecializedViewProps } from "../specialized";
+import NativeSFSymbol from "./SFSymbolNativeComponent";
+export type SFSymbolScale = "small" | "medium" | "large";
+export interface SFSymbolProps extends Omit<SpecializedViewProps, "children"> {
+  name: string;
+  color?: ColorValue;
+  scale?: SFSymbolScale;
+  size?: number;
+  yOffset?: number;
+}
+export function getSFSymbolAvailability() { return macosViewAvailability("SFSymbol"); }
+export function SFSymbol({ name, color, scale = "medium", size = 24, yOffset = 0, ref, onError, style, ...props }: SFSymbolProps) {
+  identifier(name, "symbol name"); finite(size, "symbol size", 1); finite(yOffset, "symbol offset", -Infinity);
+  if (!["small", "medium", "large"].includes(scale)) throw new SparkError("E_INVALID_ARGUMENT", "Invalid symbol scale");
+  const control = useControl({ ref, onError }, getSFSymbolAvailability());
+  const frame = [{ height: size, width: size }, style];
+  function error(event: NativeSyntheticEvent<{ name: string; message: string }>) {
+    if (!control.active()) return;
+    if (typeof event?.nativeEvent?.name !== "string" || typeof event?.nativeEvent?.message !== "string") { control.error(new SparkError("E_INVALID_DATA", "Invalid symbol error")); return; }
+    if (event.nativeEvent.name === name) control.error(new SparkError("E_NOT_FOUND", event.nativeEvent.message));
+  }
+  if (control.failed) return <View {...props} ref={control.ref} style={frame} />;
+  return <NativeSFSymbol {...props} ref={control.ref} name={name} color={color} scale={scale} size={size} yOffset={yOffset} style={frame} onSymbolError={error} />;
+}

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

@@ -0,0 +1,25 @@
+import type { HostComponent, ViewProps } from "react-native";
+import { codegenNativeComponent } from "react-native";
+import type { DirectEventHandler, Double } from "react-native/Libraries/Types/CodegenTypes";
+
+export type SidebarItemRightClickEvent = Readonly<{
+  altKey: boolean;
+  button: Double;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  pageX: Double;
+  pageY: Double;
+  shiftKey: boolean;
+  x: Double;
+  y: Double;
+}>;
+
+export interface NativeProps extends ViewProps {
+  autoHeight?: boolean;
+  itemId?: string;
+  onRightClick?: DirectEventHandler<SidebarItemRightClickEvent>;
+  rowHeight?: Double;
+  selectable?: boolean;
+}
+
+export default codegenNativeComponent<NativeProps>("SidebarItem") as HostComponent<NativeProps>;

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

@@ -0,0 +1,24 @@
+import type { HostComponent, ViewProps } from "react-native";
+import { codegenNativeComponent } from "react-native";
+import type { DirectEventHandler, Double, Int32 } from "react-native/Libraries/Types/CodegenTypes";
+
+export type SidebarSelectionChangeEvent = Readonly<{
+  id: string;
+}>;
+
+export type SidebarLayoutEvent = Readonly<{
+  height: Double;
+  width: Double;
+}>;
+
+export interface NativeProps extends ViewProps {
+  contentInsetTop?: Double;
+  defaultRowHeight?: Double;
+  itemsJson?: string;
+  onSidebarLayout?: DirectEventHandler<SidebarLayoutEvent>;
+  onSidebarSelectionChange?: DirectEventHandler<SidebarSelectionChangeEvent>;
+  selectedId?: string;
+  selectionRevision?: Int32;
+}
+
+export default codegenNativeComponent<NativeProps>("Sidebar") as HostComponent<NativeProps>;

package/vendor/node_modules/@legendapp/spark-ui/src/sidebar/index.tsx

@@ -0,0 +1,104 @@
+import { Children, Fragment, createContext, isValidElement, useContext, useMemo, useState, type ReactElement, type ReactNode } from "react";
+import { Text, View, type NativeSyntheticEvent } from "react-native";
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { useControl } from "../control";
+import { callback, finite, identifier, macosViewAvailability, type SpecializedViewProps } from "../specialized";
+import NativeSidebar from "./SidebarNativeComponent";
+import NativeSidebarItem from "./SidebarItemNativeComponent";
+export interface SidebarItemData { id: string; label: string; selectable?: boolean }
+export type SidebarRowHeight = number | "auto";
+export interface SidebarSelectionEvent { id: string | null }
+export interface SidebarContentLayoutEvent { width: number; height: number }
+export interface SidebarContextMenuEvent {
+  id: string;
+  /** Logical top-left coordinates within the row and the owning window's content. */
+  position: { x: number; y: number };
+  windowPosition: { x: number; y: number };
+  modifiers: { alt: boolean; control: boolean; meta: boolean; shift: boolean };
+}
+export interface SidebarBaseProps extends Omit<SpecializedViewProps, "children"> {
+  contentInsetTop?: number;
+  defaultRowHeight?: number;
+  selectedId: string | null;
+  onContentLayout?: (event: SidebarContentLayoutEvent) => void;
+  onSelectionChange: (event: SidebarSelectionEvent) => void;
+}
+export type SidebarProps = SidebarBaseProps & ({ items: readonly SidebarItemData[]; children?: never } | { items?: never; children: ReactNode });
+export interface SidebarItemProps extends SpecializedViewProps {
+  id: string;
+  rowHeight?: SidebarRowHeight;
+  selectable?: boolean;
+  onContextMenu?: (event: SidebarContextMenuEvent) => void;
+}
+const SidebarContext = createContext(false);
+export function getSidebarAvailability() {
+  const availability = macosViewAvailability("Sidebar");
+  return availability.available ? macosViewAvailability("SidebarItem") : availability;
+}
+function childRows(children: ReactNode): ReactElement<SidebarItemProps>[] {
+  const rows: ReactElement<SidebarItemProps>[] = [];
+  Children.forEach(children, child => {
+    if (child === null) return;
+    if (isValidElement<{ children?: ReactNode }>(child) && child.type === Fragment) { rows.push(...childRows(child.props.children)); return; }
+    if (!isValidElement<SidebarItemProps>(child) || child.type !== SidebarItem) throw new SparkError("E_INVALID_ARGUMENT", "Sidebar children must be SidebarItem elements or fragments");
+    rows.push(child);
+  });
+  return rows;
+}
+export function Sidebar({ items, children, selectedId, contentInsetTop = 0, defaultRowHeight = 28, onContentLayout, onSelectionChange, ref, onError, ...props }: SidebarProps) {
+  finite(contentInsetTop, "content inset"); finite(defaultRowHeight, "row height", 1);
+  callback(onContentLayout, "content layout");
+  if (typeof onSelectionChange !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Sidebar selection is controlled and requires onSelectionChange");
+  if (items !== undefined && (children !== undefined || !Array.isArray(items))) throw new SparkError("E_INVALID_ARGUMENT", "Use either items or SidebarItem children");
+  const { selectableIds, itemsJson } = useMemo(() => {
+    const rows = items === undefined ? childRows(children) : [];
+    const entries = items === undefined ? rows.map(row => ({ id: row.props.id, selectable: row.props.selectable })) : items;
+    const ids = new Set<string>(), selectableIds = new Set<string>();
+    for (const item of entries) {
+      if (!item || typeof item !== "object") throw new SparkError("E_INVALID_ARGUMENT", "Invalid sidebar item");
+      identifier(item.id, "sidebar ID");
+      if (ids.has(item.id)) throw new SparkError("E_INVALID_ARGUMENT", "Sidebar IDs must be unique"); ids.add(item.id);
+      if (item.selectable !== undefined && typeof item.selectable !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "Expected selectable boolean");
+      if (items !== undefined) identifier((item as SidebarItemData).label, "sidebar label");
+      if (item.selectable !== false) selectableIds.add(item.id);
+    }
+    return { selectableIds, itemsJson: items === undefined ? "" : JSON.stringify(items.map(({ id, label, selectable = true }) => ({ id, title: label, selectable }))) };
+  }, [items, children]);
+  if (selectedId !== null && !selectableIds.has(selectedId)) throw new SparkError("E_INVALID_ARGUMENT", "Selected sidebar ID must identify a selectable row");
+  const control = useControl({ ref, onError }, getSidebarAvailability());
+  const [selectionRevision, revise] = useState(0);
+  function selection(event: NativeSyntheticEvent<{ id: string }>) {
+    if (!control.active()) return;
+    const id = event?.nativeEvent?.id;
+    if (typeof id !== "string" || (id !== "" && !selectableIds.has(id))) { control.error(new SparkError("E_INVALID_DATA", "Invalid sidebar selection")); return; }
+    revise(value => value + 1); onSelectionChange?.({ id: id || null });
+  }
+  function layout(event: NativeSyntheticEvent<{ width: number; height: number }>) {
+    if (!control.active()) return;
+    try { finite(event?.nativeEvent?.width, "content width"); finite(event?.nativeEvent?.height, "content height"); }
+    catch (cause) { control.error(new SparkError("E_INVALID_DATA", "Invalid sidebar layout", { cause })); return; }
+    onContentLayout?.({ width: event.nativeEvent.width, height: event.nativeEvent.height });
+  }
+  if (control.failed) return <View {...props} ref={control.ref}><SidebarContext.Provider value>{items?.map(item => <Text key={item.id}>{item.label}</Text>) ?? children}</SidebarContext.Provider></View>;
+  return <NativeSidebar {...props} ref={control.ref} itemsJson={itemsJson} selectedId={selectedId ?? ""} selectionRevision={selectionRevision} contentInsetTop={contentInsetTop} defaultRowHeight={defaultRowHeight} onSidebarLayout={layout} onSidebarSelectionChange={selection}>
+    <SidebarContext.Provider value>{children}</SidebarContext.Provider>
+  </NativeSidebar>;
+}
+export function SidebarItem({ id, children, rowHeight, selectable = true, onContextMenu, ref, onError, ...props }: SidebarItemProps) {
+  if (!useContext(SidebarContext)) throw new SparkError("E_INVALID_ARGUMENT", "SidebarItem requires a Sidebar parent");
+  identifier(id, "sidebar ID"); callback(onContextMenu, "context menu");
+  if (rowHeight !== undefined && rowHeight !== "auto") finite(rowHeight, "row height", 1);
+  if (typeof selectable !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "Expected selectable boolean");
+  const control = useControl({ ref, onError }, getSidebarAvailability());
+  function contextMenu(event: NativeSyntheticEvent<{ x: number; y: number; pageX: number; pageY: number; altKey: boolean; ctrlKey: boolean; metaKey: boolean; shiftKey: boolean }>) {
+    if (!control.active()) return;
+    const data = event?.nativeEvent;
+    try {
+      for (const key of ["x", "y", "pageX", "pageY"] as const) finite(data?.[key], key, -Infinity);
+      for (const key of ["altKey", "ctrlKey", "metaKey", "shiftKey"] as const) if (typeof data[key] !== "boolean") throw new Error("Invalid modifiers");
+    } catch (cause) { control.error(new SparkError("E_INVALID_DATA", "Invalid sidebar context menu event", { cause })); return; }
+    onContextMenu?.({ id, position: { x: data.x, y: data.y }, windowPosition: { x: data.pageX, y: data.pageY }, modifiers: { alt: data.altKey, control: data.ctrlKey, meta: data.metaKey, shift: data.shiftKey } });
+  }
+  if (control.failed) return <View {...props} ref={control.ref}>{children}</View>;
+  return <NativeSidebarItem {...props} ref={control.ref} itemId={id} autoHeight={rowHeight === "auto"} rowHeight={typeof rowHeight === "number" ? rowHeight : 0} selectable={selectable} onRightClick={contextMenu}>{children}</NativeSidebarItem>;
+}

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

@@ -0,0 +1,22 @@
+import { Platform, UIManager, type ViewProps } from "react-native";
+import type { Ref } from "react";
+import { SparkError, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+import type { ControlRef } from "./types";
+export interface SpecializedViewProps extends ViewProps { ref?: Ref<ControlRef>; onError?: (error: SparkError) => void }
+export function macosViewAvailability(name: string, minimumVersion = 14): Availability {
+  if (Platform.OS !== "macos") return { available: false, reason: "unsupported-platform" };
+  if (Number.parseInt(String(Platform.Version), 10) < minimumVersion) return { available: false, reason: "host-restriction" };
+  return UIManager.hasViewManagerConfig(name) ? { available: true } : { available: false, reason: "missing-module" };
+}
+export function finite(value: unknown, name: string, minimum = 0, maximum = Infinity): asserts value is number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum) throw new SparkError("E_INVALID_ARGUMENT", `Invalid ${name}`);
+}
+export function identifier(value: unknown, name = "ID"): asserts value is string {
+  if (typeof value !== "string" || !value.length || value.includes("\0")) throw new SparkError("E_INVALID_ARGUMENT", `Expected a nonempty ${name}`);
+}
+export function appearance(value: unknown) {
+  if (!["system", "light", "dark"].includes(value as string)) throw new SparkError("E_INVALID_ARGUMENT", "Invalid appearance");
+}
+export function callback(value: unknown, name: string) {
+  if (value !== undefined && typeof value !== "function") throw new SparkError("E_INVALID_ARGUMENT", `Expected ${name} callback`);
+}

package/vendor/node_modules/@legendapp/spark-ui/src/swipe-actions/SwipeActionsNativeComponent.ts

@@ -0,0 +1,11 @@
+import type { HostComponent, ViewProps } from "react-native";
+import { codegenNativeComponent } from "react-native";
+import type { DirectEventHandler } from "react-native/Libraries/Types/CodegenTypes";
+
+export interface NativeProps extends ViewProps {
+  leadingActionsJson: string;
+  trailingActionsJson: string;
+  onSwipeAction?: DirectEventHandler<Readonly<{ actionId: string }>>;
+}
+
+export default codegenNativeComponent<NativeProps>("SwipeActions") as HostComponent<NativeProps>;

package/vendor/node_modules/@legendapp/spark-ui/src/swipe-actions/index.tsx

@@ -0,0 +1,41 @@
+import { View, type NativeSyntheticEvent } from "react-native";
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { useControl } from "../control";
+import { identifier, macosViewAvailability, type SpecializedViewProps } from "../specialized";
+import NativeSwipeActions from "./SwipeActionsNativeComponent";
+/** `dismisses` slides the row away on commit; remove or remount the row to recover after failure/undo. */
+export interface SwipeAction { id: string; title: string; symbol: string; color: string; dismisses?: boolean }
+export interface SwipeActionsProps extends SpecializedViewProps {
+  /** Revealed by swiping right; the first action is outermost and runs on a full swipe. */
+  leadingActions?: readonly SwipeAction[];
+  /** Revealed by swiping left; the first action is outermost and runs on a full swipe. */
+  trailingActions?: readonly SwipeAction[];
+  onAction: (id: string) => void;
+}
+const hexColor = /^#(?:[0-9a-f]{6}|[0-9a-f]{8})$/i;
+function actionsJson(actions: readonly SwipeAction[], ids: Set<string>) {
+  if (!Array.isArray(actions)) throw new SparkError("E_INVALID_ARGUMENT", "Swipe actions must be arrays");
+  for (const action of actions) {
+    identifier(action?.id, "swipe action ID"); identifier(action.title, "swipe action title"); identifier(action.symbol, "swipe action symbol");
+    if (typeof action.color !== "string" || !hexColor.test(action.color)) throw new SparkError("E_INVALID_ARGUMENT", "Swipe action colors are #RRGGBB or #RRGGBBAA");
+    if (action.dismisses !== undefined && typeof action.dismisses !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "Invalid swipe action dismisses");
+    if (ids.has(action.id)) throw new SparkError("E_INVALID_ARGUMENT", "Duplicate swipe action ID");
+    ids.add(action.id);
+  }
+  return JSON.stringify(actions.map(({ id, title, symbol, color, dismisses = false }) => ({ id, title, symbol, color, dismisses })));
+}
+export function getSwipeActionsAvailability() { return macosViewAvailability("SwipeActions"); }
+/** Native trackpad swipe actions. In recycling lists, key this view by the logical row ID. */
+export function SwipeActions({ leadingActions = [], trailingActions = [], onAction, ref, onError, ...props }: SwipeActionsProps) {
+  if (typeof onAction !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected swipe action callback");
+  const ids = new Set<string>(), leading = actionsJson(leadingActions, ids), trailing = actionsJson(trailingActions, ids);
+  const control = useControl({ ref, onError }, getSwipeActionsAvailability());
+  function action(event: NativeSyntheticEvent<{ actionId: string }>) {
+    if (!control.active()) return;
+    const id = event?.nativeEvent?.actionId;
+    if (typeof id !== "string" || !ids.has(id)) { control.error(new SparkError("E_INVALID_DATA", "Invalid swipe action")); return; }
+    onAction(id);
+  }
+  if (control.failed) return <View {...props} ref={control.ref} />;
+  return <NativeSwipeActions {...props} ref={control.ref} leadingActionsJson={leading} trailingActionsJson={trailing} onSwipeAction={action} />;
+}

package/vendor/node_modules/@legendapp/spark-ui/src/text-input-search/TextInputSearchNativeComponent.ts

@@ -0,0 +1,33 @@
+import type { HostComponent, ViewProps } from "react-native";
+import { codegenNativeComponent } from "react-native";
+import codegenNativeCommands from "react-native/Libraries/Utilities/codegenNativeCommands";
+import type { DirectEventHandler, Int32, WithDefault } from "react-native/Libraries/Types/CodegenTypes";
+
+export type TextInputSearchChangeEvent = {
+  text: string;
+  eventCount: Int32;
+};
+
+export interface NativeProps extends ViewProps {
+  appearance?: string;
+  defaultText?: string;
+  controlled?: WithDefault<boolean, false>;
+  disabled?: WithDefault<boolean, false>;
+  eventCount?: Int32;
+  onChangeText?: DirectEventHandler<TextInputSearchChangeEvent>;
+  placeholder?: string;
+  text?: string;
+}
+
+type NativeComponentType = HostComponent<NativeProps>;
+
+export interface NativeCommands {
+  focus: (viewRef: React.ElementRef<NativeComponentType>) => void;
+  blur: (viewRef: React.ElementRef<NativeComponentType>) => void;
+}
+
+export const Commands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ["focus", "blur"],
+});
+
+export default codegenNativeComponent<NativeProps>("TextInputSearch") as NativeComponentType;

package/vendor/node_modules/@legendapp/spark-ui/src/text-input-search/index.tsx

@@ -0,0 +1,34 @@
+import { createElement, useCallback, useImperativeHandle, useRef, type ElementRef, type Ref } from "react";
+import { Text, View, type NativeSyntheticEvent } from "react-native";
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+import { useControl, useTextValue } from "../control";
+import { macosViewAvailability, appearance } from "../specialized";
+import type { ControlRef, ControlledTextInputProps, UncontrolledTextInputProps } from "../types";
+import NativeSearch, { Commands } from "./TextInputSearchNativeComponent";
+export type TextInputSearchProps = (Omit<ControlledTextInputProps, "ref"> | Omit<UncontrolledTextInputProps, "ref">) & {
+  appearance?: "dark" | "light" | "system";
+  placeholder?: string;
+  ref?: Ref<TextInputSearchRef>;
+};
+export interface TextInputSearchRef extends ControlRef { focus(): void; blur(): void }
+export function getSearchAvailability() { return macosViewAvailability("TextInputSearch"); }
+export function TextInputSearch({ ref, appearance: theme = "system", placeholder = "", ...props }: TextInputSearchProps) {
+  appearance(theme);
+  if (typeof placeholder !== "string") throw new SparkError("E_INVALID_ARGUMENT", "Expected search placeholder");
+  const layout = useRef<ControlRef>(null), native = useRef<ElementRef<typeof NativeSearch>>(null);
+  const control = useControl({ ...props, ref: layout }, getSearchAvailability()), value = useTextValue(props);
+  const nativeRef = useCallback((view: ElementRef<typeof NativeSearch> | null) => { native.current = view; control.ref(view); }, [control.ref]);
+  useImperativeHandle(ref, () => ({
+    measureInWindow(callback) { if (!layout.current) throw new SparkError("E_CLOSED", "Search input is not mounted"); layout.current.measureInWindow(callback); },
+    focus() { if (!native.current) throw new SparkError("E_CLOSED", "Search input is not mounted or available"); Commands.focus(native.current); },
+    blur() { if (!native.current) throw new SparkError("E_CLOSED", "Search input is not mounted or available"); Commands.blur(native.current); },
+  }), []);
+  function changed(event: NativeSyntheticEvent<{ text: string; eventCount: number }>) {
+    if (!control.active()) return;
+    const data = event?.nativeEvent;
+    if (typeof data?.text !== "string" || !Number.isSafeInteger(data.eventCount) || data.eventCount < 1 || data.eventCount > 2147483647) { control.error(new SparkError("E_INVALID_DATA", "Invalid search input event")); return; }
+    if (value.acknowledge(data.eventCount)) props.onChangeText?.(data.text);
+  }
+  if (control.failed) return <View ref={control.ref} style={props.style} testID={props.testID} accessible accessibilityLabel={props.accessibilityLabel} accessibilityState={{ disabled: true }}><Text>{value.controlled ? value.text : value.defaultText}</Text></View>;
+  return createElement(NativeSearch, { ref: nativeRef, appearance: theme, placeholder, disabled: control.disabled, controlled: value.controlled, eventCount: value.eventCount, defaultText: value.defaultText, text: value.text, onChangeText: changed, style: props.style, testID: props.testID, accessibilityLabel: props.accessibilityLabel });
+}

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.4",
   "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.4"
   },
   "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");