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

package/vendor/node_modules/@legendapp/spark-documents/src/controller.ts

@@ -0,0 +1,97 @@
+import { createMenu, type Menu, type MenuAction, type MenuRootItem } from "@legendapp/spark-native-menu";
+import { createPrimaryWindowLifecycle } from "@legendapp/spark-desktop-windows/src/windows/primaryWindowLifecycle";
+import { SparkError, asyncRegistration, type AsyncRegistration, type Subscription } from "@legendapp/spark-desktop-app/src/contracts";
+import { subscribeToOpenRequests } from "./requests";
+
+export interface DocumentAppController extends AsyncRegistration {
+  /** Resolves after document listeners and the menu are installed. Initial-open work reports through reportError. */
+  readonly ready: Promise<void>;
+  isDocumentWindowOpen(): boolean;
+  setDocumentWindowOpen(isOpen: boolean): void;
+  reportError(error: unknown): void;
+  subscribe(listener: () => void): Subscription;
+  updateMenus(menus: readonly MenuRootItem[]): Promise<void>;
+}
+export interface DocumentAppControllerOptions {
+  onMenuAction?: (action: MenuAction, controller: DocumentAppController) => void | Promise<void>;
+  launchArguments?: string[];
+  menus: readonly MenuRootItem[];
+  onInitialOpen: (launchArguments: string[] | undefined, controller: DocumentAppController) => Promise<void> | void;
+  onOpenDocument?: (path: string, controller: DocumentAppController) => Promise<void> | void;
+  onReopenRequested?: (controller: DocumentAppController) => Promise<void> | void;
+  ownerId: string;
+  reportError: (error: unknown) => void;
+  windowId: string;
+}
+
+/** An application-owned controller. Await ready; remove also works during setup or after setup fails. */
+export function createDocumentAppController(options: DocumentAppControllerOptions): DocumentAppController {
+  const { ownerId, windowId, menus, onMenuAction, onInitialOpen, onOpenDocument, onReopenRequested, reportError } = options;
+  if (![ownerId, windowId].every(id => typeof id === "string" && /^[a-zA-Z0-9_-]{1,100}$/.test(id))) {
+    throw new SparkError("E_INVALID_ARGUMENT", "Expected document owner and window IDs");
+  }
+  const launchArguments = options.launchArguments?.slice();
+  let active = true, windowOpen = false, menu: Menu | undefined;
+  let requests: Subscription | undefined, lifecycle: Subscription | undefined;
+  const listeners = new Set<() => void>(), handled = new Set<string>();
+  const stop = () => { active = false; listeners.clear(); requests?.remove(); lifecycle?.remove(); };
+  const registration = asyncRegistration(stop, async () => {
+    await controller.ready.catch(() => {});
+    requests?.remove(); lifecycle?.remove();
+    await menu?.remove();
+  });
+  const controller: DocumentAppController = {
+    ready: Promise.resolve().then(async () => {
+      if (!active) return;
+      try {
+        if (onOpenDocument) requests = await subscribeToOpenRequests(event => {
+          if (!active || event.type !== "file" || handled.has(event.id)) return;
+          handled.add(event.id);
+          if (handled.size > 200) handled.delete(handled.values().next().value!);
+          void Promise.resolve().then(() => { if (active) return onOpenDocument(event.path, controller); }).catch(reportError);
+        });
+        if (!active) { requests?.remove(); return; }
+        menu = await createMenu({ id: ownerId, items: menus, onAction: action => {
+          if (active) {
+            try { void Promise.resolve(onMenuAction?.(action, controller)).catch(reportError); }
+            catch (error) { reportError(error); }
+          }
+        } });
+        if (!active) return;
+        lifecycle = createPrimaryWindowLifecycle({
+          windowId,
+          onInitialOpen: () => onInitialOpen(launchArguments, controller),
+          onReopenRequested: () => onReopenRequested ? onReopenRequested(controller) : onInitialOpen(undefined, controller),
+          onWindowClosed: () => controller.setDocumentWindowOpen(false),
+          onError: reportError,
+        });
+      } catch (error) {
+        stop();
+        try { await menu?.remove(); }
+        catch (cleanup) { throw new SparkError("E_NATIVE", "Document setup and cleanup failed; retry controller.remove()", { cause: new AggregateError([error, cleanup]) }); }
+        throw error;
+      }
+    }),
+    isDocumentWindowOpen: () => windowOpen,
+    setDocumentWindowOpen(isOpen) {
+      if (!active) throw new SparkError("E_CLOSED", "Document controller was removed");
+      if (typeof isOpen !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "Expected a boolean window state");
+      if (windowOpen !== isOpen) { windowOpen = isOpen; for (const listener of listeners) listener(); }
+    },
+    reportError,
+    subscribe(listener) {
+      if (!active) throw new SparkError("E_CLOSED", "Document controller was removed");
+      listeners.add(listener); return { remove() { listeners.delete(listener); } };
+    },
+    async updateMenus(items) {
+      if (!active) throw new SparkError("E_CLOSED", "Document controller was removed");
+      await controller.ready;
+      if (!active) throw new SparkError("E_CLOSED", "Document controller was removed");
+      await menu!.update({ items });
+    },
+    remove: registration.remove,
+  };
+  // Removal need not await readiness first; the original promise still rejects to awaiters.
+  void controller.ready.catch(() => {});
+  return controller;
+}

package/vendor/node_modules/@legendapp/spark-documents/src/documentTransition.ts

@@ -0,0 +1,13 @@
+/** Serialize destructive document transitions without queuing stale user intent. */
+export function createDocumentTransitionGuard() {
+  let pending = false;
+  return async (prepare: () => Promise<boolean>, transition: () => void | Promise<void>) => {
+    if (pending) return false;
+    pending = true;
+    try {
+      if (!await prepare()) return false;
+      await transition();
+      return true;
+    } finally { pending = false; }
+  };
+}

package/vendor/node_modules/@legendapp/spark-documents/src/hooks.ts

@@ -0,0 +1,139 @@
+import { useEffect, useLayoutEffect, useRef, useState } from "react";
+import type { AsyncRegistration, Subscription } from "@legendapp/spark-desktop-app/src/contracts";
+import { createDocumentAppController, type DocumentAppController, type DocumentAppControllerOptions } from "./controller";
+import { watchDocumentReload, type DocumentReloadOptions } from "./reload";
+
+export interface UseWatchedDocumentReloadOptions extends Omit<DocumentReloadOptions, "path"> {
+  path: string | null | undefined;
+  enabled?: boolean;
+  onCleanupError?: (error: unknown, registration: AsyncRegistration) => void;
+}
+type ReloadOwner = { registration: AsyncRegistration; removing?: Promise<void> };
+type ReloadLifecycle = { tail: Promise<void>; owner?: ReloadOwner };
+export function useWatchedDocumentReload(options: UseWatchedDocumentReloadOptions): void {
+  const latest = useRef(options);
+  const lifecycleRef = useRef<ReloadLifecycle | null>(null);
+  if (!lifecycleRef.current) lifecycleRef.current = { tail: Promise.resolve() };
+  const lifecycle = lifecycleRef.current;
+  useLayoutEffect(() => { latest.current = options; });
+  const { path, enabled = true, delayMs } = options;
+  useEffect(() => {
+    if (!enabled || !path) return;
+    let active = true, owned: ReloadOwner | undefined;
+    const report = (error: unknown) => {
+      try { latest.current.onError(error); }
+      catch (callbackError) { console.error(callbackError); }
+    };
+    const remove = (owner: ReloadOwner) => {
+      if (!owner.removing) owner.removing = owner.registration.remove().then(() => {
+        if (lifecycle.owner === owner) lifecycle.owner = undefined;
+      }).catch(error => {
+        try {
+          if (latest.current.onCleanupError) latest.current.onCleanupError(error, owner.registration);
+          else {
+            console.error("Document reload watch cleanup failed; registration remains retryable", error, owner.registration);
+            report(error);
+          }
+        } catch (callbackError) { console.error(callbackError); }
+        throw error;
+      }).finally(() => { owner.removing = undefined; });
+      return owner.removing;
+    };
+    const creation = lifecycle.tail.then(async () => {
+      if (!active) return;
+      try {
+        if (lifecycle.owner) await remove(lifecycle.owner);
+      } catch { return; }
+      if (!active) return;
+      try {
+        const registration = await watchDocumentReload({
+          path, delayMs,
+          onReload: () => { if (active) return latest.current.onReload(); },
+          shouldReload: () => active && (latest.current.shouldReload?.() ?? true),
+          onError: error => { if (active) report(error); },
+        });
+        owned = { registration };
+        lifecycle.owner = owned;
+      } catch (error) { if (active) report(error); }
+    });
+    lifecycle.tail = creation;
+    return () => {
+      active = false;
+      const cleanup = creation.then(async () => { if (owned) await remove(owned).catch(() => {}); });
+      lifecycle.tail = cleanup;
+    };
+  }, [path, enabled, delayMs]);
+}
+
+export interface UseDocumentAppControllerOptions extends DocumentAppControllerOptions {
+  onCleanupError?: (error: unknown, controller: DocumentAppController) => void;
+}
+export type DocumentAppControllerState =
+  | { status: "loading" }
+  | { status: "ready"; controller: DocumentAppController }
+  | { status: "error"; error: unknown };
+
+/** Component-owned convenience. Use the factory for an application-owned lifetime. */
+export function useDocumentAppController(options: UseDocumentAppControllerOptions): DocumentAppControllerState {
+  const latest = useRef(options);
+  useLayoutEffect(() => { latest.current = options; });
+  const [state, setState] = useState<DocumentAppControllerState>({ status: "loading" });
+  const current = useRef<{ controller?: DocumentAppController; items: DocumentAppControllerOptions["menus"]; active: boolean; ready: boolean } | undefined>(undefined);
+  const cleanup = useRef<{ promise: Promise<void>; controller?: DocumentAppController }>({ promise: Promise.resolve() });
+  const handlesDocuments = !!options.onOpenDocument;
+  useEffect(() => {
+    const owner: NonNullable<typeof current.current> = { items: options.menus, active: true, ready: false };
+    current.current = owner;
+    let subscription: Subscription | undefined;
+    setState({ status: "loading" });
+    const report = (error: unknown) => { if (owner.active) setState({ status: "error", error }); latest.current.reportError(error); };
+    const previous = cleanup.current;
+    const setup = previous.promise.catch(() => previous.controller?.remove()).then(async () => {
+      if (!owner.active) return;
+      const initialItems = owner.items;
+      const controller = createDocumentAppController({
+        ownerId: options.ownerId, windowId: options.windowId, menus: initialItems,
+        launchArguments: options.launchArguments,
+        onMenuAction: (action, value) => { if (owner.active) return latest.current.onMenuAction?.(action, value); },
+        onInitialOpen: (args, value) => { if (owner.active) return latest.current.onInitialOpen(args, value); },
+        onOpenDocument: handlesDocuments ? (path, value) => { if (owner.active) return latest.current.onOpenDocument?.(path, value); } : undefined,
+        onReopenRequested: value => {
+          if (owner.active) return latest.current.onReopenRequested ? latest.current.onReopenRequested(value) : latest.current.onInitialOpen(undefined, value);
+        },
+        reportError: error => latest.current.reportError(error),
+      });
+      owner.controller = controller;
+      await controller.ready;
+      if (owner.active) {
+        owner.ready = true;
+        if (owner.items !== initialItems) await controller.updateMenus(owner.items).catch(error => latest.current.reportError(error));
+        if (!owner.active) return;
+        subscription = controller.subscribe(() => setState({ status: "ready", controller }));
+        setState({ status: "ready", controller });
+      }
+    });
+    void setup.catch(report);
+    return () => {
+      owner.active = false; subscription?.remove();
+      // Stop callbacks immediately, even if setup is waiting on a native registration.
+      if (owner.controller) {
+        const controller = owner.controller;
+        const promise = controller.remove();
+        cleanup.current = { promise, controller };
+        void promise.catch(error => {
+          if (latest.current.onCleanupError) latest.current.onCleanupError(error, controller);
+          else latest.current.reportError(error);
+        });
+      }
+    };
+  }, [options.ownerId, options.windowId, handlesDocuments]);
+  useEffect(() => {
+    const owner = current.current;
+    if (!owner?.active || owner.items === options.menus) return;
+    owner.items = options.menus;
+    if (owner.ready && owner.controller) void owner.controller.updateMenus(options.menus).catch(error => {
+      if (owner.active) latest.current.reportError(error);
+    });
+  }, [options.menus]);
+  return state;
+}

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

@@ -0,0 +1,50 @@
+import { openFileDialog } from "@legendapp/spark-file-dialog";
+export type { AsyncRegistration, Subscription } from "@legendapp/spark-desktop-app/src/contracts";
+export * from "./requests";
+export { createDocumentTransitionGuard } from "./documentTransition";
+export * from "./controller";
+export * from "./reload";
+export * from "./hooks";
+
+export interface OpenSelectedDocumentPathOptions {
+  allowedFileTypes: readonly string[];
+  invalidSelectionMessage?: string;
+  isDocumentPath: (path: string) => boolean;
+}
+export interface GetLaunchDocumentPathOptions {
+  isDocumentPath: (path: string) => boolean;
+  launchArguments?: string[];
+}
+
+export function getLaunchDocumentPath({
+  isDocumentPath,
+  launchArguments,
+}: GetLaunchDocumentPathOptions) {
+  const argv = typeof process !== "undefined" && Array.isArray(process.argv) ? process.argv : [];
+  return launchArguments?.find(isDocumentPath) ?? argv.find(isDocumentPath) ?? null;
+}
+
+export async function openSelectedDocumentPath({
+  allowedFileTypes,
+  invalidSelectionMessage,
+  isDocumentPath,
+}: OpenSelectedDocumentPathOptions) {
+  const result = await openFileDialog({
+    filters: [{ extensions: allowedFileTypes }],
+    selection: "files",
+  });
+  const paths = result.canceled ? [] : result.paths;
+  const path = paths.find(isDocumentPath) ?? null;
+
+  if (path) {
+    return path;
+  }
+
+  if (paths && paths.length > 0) {
+    throw new Error(
+      invalidSelectionMessage ?? `Choose a supported file (${allowedFileTypes.map((type) => `.${type}`).join(", ")}).`,
+    );
+  }
+
+  return null;
+}

package/vendor/node_modules/@legendapp/spark-documents/src/reload.ts

@@ -0,0 +1,39 @@
+import { watch } from "@legendapp/spark-file-system";
+import { SparkError, asyncRegistration, type AsyncRegistration } from "@legendapp/spark-desktop-app/src/contracts";
+
+export interface DocumentReloadOptions {
+  path: string;
+  delayMs?: number;
+  onReload: () => void | Promise<void>;
+  onError: (error: unknown) => void;
+  shouldReload?: () => boolean;
+}
+
+/** Debounces file invalidations. Removal stops queued reloads and awaits any running reload. */
+export async function watchDocumentReload(options: DocumentReloadOptions): Promise<AsyncRegistration> {
+  const { path, delayMs = 100, onReload, onError, shouldReload } = options;
+  if (!Number.isFinite(delayMs) || delayMs < 0 || delayMs > 2147483647) {
+    throw new SparkError("E_INVALID_ARGUMENT", "Expected a nonnegative timer delay");
+  }
+  let active = true, ready = false, invalidated = false, timeout: ReturnType<typeof setTimeout> | undefined;
+  let pending = Promise.resolve();
+  const invalidate = () => {
+    if (!active) return;
+    if (!ready) { invalidated = true; return; }
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      pending = pending.then(async () => {
+        if (active && (!shouldReload || shouldReload())) await onReload();
+      }).catch(onError);
+    }, delayMs);
+  };
+  // Native backends can report an invalidation before registration is acknowledged.
+  // Do not run application work until creation succeeds.
+  const subscription = await watch(path, invalidate);
+  ready = true;
+  if (invalidated) invalidate();
+  return asyncRegistration(() => { active = false; clearTimeout(timeout); }, async () => {
+    await subscription.remove();
+    await pending;
+  });
+}

package/vendor/node_modules/@legendapp/spark-documents/src/requests.ts

@@ -0,0 +1,15 @@
+import { Platform } from "react-native";
+import { callLinks, linksCommand } from "@legendapp/spark-desktop-links/src/native";
+import { nativePath } from "@legendapp/spark-desktop-app/src/contracts/path";
+import { SparkError } from "@legendapp/spark-desktop-app/src/contracts";
+export { subscribeToOpenRequests, type OpenRequest } from "@legendapp/spark-desktop-app/src/open-requests";
+export interface RecentDocument { path: string; name: string }
+export async function noteRecentDocument(path: string): Promise<void> { await linksCommand("noteRecent", { path: nativePath(path, Platform.OS) }); }
+export function clearRecentDocuments(): Promise<void> { return linksCommand("clearRecent"); }
+export async function getRecentDocuments(): Promise<RecentDocument[]> {
+  const paths = await callLinks("recent", {}, (value): value is string[] => Array.isArray(value) && value.every(item => typeof item === "string"));
+  return paths.map(value => {
+    try { const path = nativePath(value, Platform.OS); return { path, name: (Platform.OS === "windows" ? path.replaceAll("\\", "/") : path).split("/").filter(Boolean).at(-1) ?? path }; }
+    catch (cause) { throw new SparkError("E_INVALID_DATA", "Recent document contains an invalid path", { cause }); }
+  });
+}

package/vendor/node_modules/@legendapp/spark-drag-drop/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-drag-drop",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.4",
   "license": "MIT",
   "main": "src/index.tsx",
   "react-native": "src/index.tsx",
@@ -22,7 +22,8 @@
     "ios": {
       "componentProvider": {
         "DesktopDragView": "RNDesktopDragView"
-      }
+      },
+      "modulesProvider": {}
     }
   },
   "spark": {
@@ -38,7 +39,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-drag-drop/src/DesktopDragViewNativeComponent.ts

@@ -6,7 +6,7 @@ export interface NativeProps extends ViewProps {
   sourceJson?: string;
   optionsJson?: string;
   disabled?: WithDefault<boolean, false>;
-  onUnavailable?: DirectEventHandler<Payload>;
+  onError?: DirectEventHandler<Payload>;
   onDrop?: DirectEventHandler<Payload>;
   onDragEnter?: DirectEventHandler<Payload>;
   onDragOver?: DirectEventHandler<Payload>;

package/vendor/node_modules/@legendapp/spark-drag-drop/src/contracts.ts

@@ -1,28 +1,83 @@
+import { SparkError, parseNativeResult } from "@legendapp/spark-desktop-app/src/contracts";
+import { nativePath } from "@legendapp/spark-desktop-app/src/contracts/path";
 export type DragOperation = "copy" | "move" | "link";
-/** Custom data values are UTF-8 strings keyed by MIME type; JSON is app-owned. */
-export type DragPayload = { files?: string[]; text?: string; urls?: string[]; data?: Record<string, string> };
-export type DragOverEvent = { x: number; y: number; operation: DragOperation };
-export type DropEvent = DragPayload & DragOverEvent;
-export type DragOptions = {
-  sourceOperations?: DragOperation[];
-  acceptedOperations?: DragOperation[];
+/** Custom values are UTF-8 strings keyed by MIME type. JSON schemas belong to the app. */
+export interface DragPayload { files?: readonly string[]; text?: string; urls?: readonly string[]; data?: Readonly<Record<string, string>> }
+/** Logical coordinates from the target's top-left corner, positive downward. */
+export interface DragOverEvent { x: number; y: number; operation: DragOperation }
+export interface DropEvent extends DragPayload, DragOverEvent {}
+export type DragEndEvent = { accepted: true; operation: DragOperation } | { accepted: false; operation: "none" };
+export interface DragOptions {
+  sourceOperations?: readonly DragOperation[];
+  acceptedOperations?: readonly DragOperation[];
   /** Built-ins: files, text, urls. Custom types use MIME names. Default: built-ins. */
-  acceptedTypes?: string[];
-};
+  acceptedTypes?: readonly string[];
+}
 const operations = ["copy", "move", "link"];
 const builtins = ["files", "text", "urls"];
 const customType = (type: string) => /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/.test(type) && !["application/x-spark-drag", "text/plain", "text/uri-list"].includes(type);
-export function dragConfiguration(source: DragPayload | undefined, options: DragOptions, platform: string) {
+const record = (value: unknown): value is Record<string, unknown> => !!value && typeof value === "object" && !Array.isArray(value);
+const strings = (value: unknown): value is string[] => Array.isArray(value) && Array.from(value).every(item => typeof item === "string");
+const url = (value: string) => /^[a-z][a-z0-9+.-]*:\S+$/i.test(value) && !/[\u0000-\u0020\u007f]/.test(value);
+function invalid(message: string): never { throw new SparkError("E_INVALID_ARGUMENT", message); }
+/** Snapshot and normalize file URLs before passing the source to native. */
+export function dragSource(source: DragPayload | undefined, platform: string, incoming = false): DragPayload | undefined {
+  if (source === undefined) return undefined;
+  if (!record(source)) invalid("Expected a drag payload");
+  for (const key of Object.keys(source)) if (![...builtins, "data"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown drag payload field: ${key}`);
+  const result: DragPayload = {};
+  if (source.files !== undefined) {
+    if (!strings(source.files)) invalid("Drag files must be an array of absolute paths or file URLs");
+    result.files = source.files.map(file => nativePath(file, platform));
+  }
+  if (source.text !== undefined) {
+    if (typeof source.text !== "string") invalid("Drag text must be a string");
+    result.text = source.text;
+  }
+  if (source.urls !== undefined) {
+    if (!strings(source.urls) || !source.urls.every(url)) invalid("Drag URLs must be absolute URLs without whitespace");
+    if (!incoming && platform === "windows" && source.urls.length > 1) throw new SparkError("E_UNSUPPORTED_OPTION", "Windows supports one URL per drag source");
+    result.urls = [...source.urls];
+  }
+  if (source.data !== undefined) {
+    if (!record(source.data) || Object.entries(source.data).some(([type, value]) => !customType(type) || typeof value !== "string")) invalid("Custom drag data must map MIME types to strings");
+    result.data = { ...source.data } as Record<string, string>;
+  }
+  if (!incoming && !result.files?.length && result.text === undefined && !result.urls?.length && !Object.keys(result.data ?? {}).length) invalid("Drag source must contain at least one representation");
+  return result;
+}
+export function dragConfiguration(source: DragPayload | undefined, options: DragOptions, platform: string): string {
+  dragSource(source, platform);
+  return dragOptions(options);
+}
+export function dragOptions(options: DragOptions): string {
+  if (!record(options)) invalid("Expected drag options");
+  for (const key of Object.keys(options)) if (!["sourceOperations", "acceptedOperations", "acceptedTypes"].includes(key)) throw new SparkError("E_UNSUPPORTED_OPTION", `Unknown drag option: ${key}`);
   for (const values of [options.sourceOperations, options.acceptedOperations]) {
-    if (values !== undefined && (!Array.isArray(values) || values.some(value => !operations.includes(value)) || new Set(values).size !== values.length)) throw new Error("Drag operations must be unique copy, move or link values");
+    if (values !== undefined && (!strings(values) || values.some(value => !operations.includes(value)) || new Set(values).size !== values.length)) invalid("Drag operations must be unique copy, move or link values");
   }
   const types = options.acceptedTypes ?? builtins;
-  if (!Array.isArray(types) || types.some(type => typeof type !== "string" || (!builtins.includes(type) && !customType(type)))) throw new Error("Invalid accepted drag type");
-  if (source) {
-    if (source.files?.some(file => typeof file !== "string" || (platform === "windows" ? !/^(?:[a-z]:[\\/]|\\\\[^\\/]+[\\/][^\\/]+)/i.test(file) : !file.startsWith("/")))) throw new Error("Drag source files must use absolute paths");
-    if (source.text !== undefined && typeof source.text !== "string") throw new Error("Drag text must be a string");
-    if (source.urls?.some(url => typeof url !== "string" || !/^[a-z][a-z0-9+.-]*:/i.test(url))) throw new Error("Drag URLs must be absolute URLs");
-    if (source.data && (typeof source.data !== "object" || Array.isArray(source.data) || Object.entries(source.data).some(([type, value]) => !customType(type) || typeof value !== "string"))) throw new Error("Custom drag data must map MIME types to strings");
-  }
+  if (!strings(types) || new Set(types).size !== types.length || types.some(type => !builtins.includes(type) && !customType(type))) invalid("Invalid or duplicate accepted drag type");
   return JSON.stringify({ sourceOperations: options.sourceOperations ?? ["copy"], acceptedOperations: options.acceptedOperations ?? ["copy"], acceptedTypes: types });
 }
+function position(value: unknown): value is DragOverEvent {
+  return record(value) && typeof value.x === "number" && Number.isFinite(value.x) && typeof value.y === "number" && Number.isFinite(value.y) && operations.includes(value.operation as string);
+}
+export function dragPosition(json: string): DragOverEvent {
+  const { x, y, operation } = parseNativeResult(json, position); return { x, y, operation };
+}
+export function dragEnd(json: string): DragEndEvent {
+  const value = parseNativeResult(json, (value): value is DragEndEvent => record(value) && (value.accepted === true ? operations.includes(value.operation as string) : value.accepted === false && value.operation === "none"));
+  return { accepted: value.accepted, operation: value.operation } as DragEndEvent;
+}
+export function dragDrop(json: string, platform: string): DropEvent {
+  const value = parseNativeResult(json, (value): value is DropEvent => position(value) && record(value));
+  // Native drops may contain no text/custom representation, unlike a requested source.
+  const { x, y, operation } = value;
+  const payload: DragPayload = {};
+  for (const key of [...builtins, "data"] as const) if (Object.hasOwn(value, key)) (payload as Record<string, unknown>)[key] = (value as unknown as Record<string, unknown>)[key];
+  try {
+    const normalized = dragSource(payload, platform, true);
+    return { ...normalized, x, y, operation };
+  } catch (cause) { throw new SparkError("E_INVALID_DATA", "Invalid native drag payload", { cause }); }
+}

package/vendor/node_modules/@legendapp/spark-drag-drop/src/index.tsx

@@ -1,17 +1,60 @@
-import React, { useCallback, useState } from "react";
-import { Platform, Text, View, type NativeSyntheticEvent, type ViewProps } from "react-native";
+import React, { useEffect, useLayoutEffect, useRef, useState } from "react";
+import { Platform, UIManager, View, type NativeSyntheticEvent, type ViewProps } from "react-native";
 import NativeView from "./DesktopDragViewNativeComponent";
-import { dragConfiguration, type DragPayload, type DragOptions, type DragOperation, type DragOverEvent, type DropEvent } from "./contracts";
-export type { DragPayload, DragOptions, DragOperation, DragOverEvent, DropEvent } from "./contracts";
-export type DragDropViewProps = ViewProps & DragOptions & { disabled?: boolean; source?: DragPayload; onDrop?: (event: DropEvent) => void; onDragEnter?: (event: DropEvent) => void; onDragOver?: (event: DragOverEvent) => void; onDragLeave?: () => void; onDragEnd?: (event: { accepted: boolean; operation: DragOperation | "none" }) => void };
-export function DragDropView({ source, sourceOperations, acceptedOperations, acceptedTypes, onDrop, onDragEnter, onDragOver, onDragLeave, onDragEnd, ...props }: DragDropViewProps) {
-  const optionsJson = dragConfiguration(source, { sourceOperations, acceptedOperations, acceptedTypes }, Platform.OS);
-  const [failure, setFailure] = useState<string>();
-  const unavailable = useCallback((event: NativeSyntheticEvent<{ json: string }>) => setFailure(JSON.parse(event.nativeEvent.json).message), []);
-  const drop = useCallback((event: NativeSyntheticEvent<{ json: string }>) => onDrop?.(JSON.parse(event.nativeEvent.json)), [onDrop]);
-  const enter = useCallback((event: NativeSyntheticEvent<{ json: string }>) => onDragEnter?.(JSON.parse(event.nativeEvent.json)), [onDragEnter]);
-  const over = useCallback((event: NativeSyntheticEvent<{ json: string }>) => onDragOver?.(JSON.parse(event.nativeEvent.json)), [onDragOver]);
-  const end = useCallback((event: NativeSyntheticEvent<{ json: string }>) => onDragEnd?.(JSON.parse(event.nativeEvent.json)), [onDragEnd]);
-  if (failure) return <View {...props}><Text>Drag and drop is unavailable: {failure}</Text>{props.children}</View>;
-  return <NativeView optionsJson={optionsJson} onDragOver={onDragOver ? over : undefined} onUnavailable={unavailable} {...props} sourceJson={source ? JSON.stringify(source) : ""} onDrop={drop} onDragEnter={enter} onDragLeave={onDragLeave} onDragEnd={end} />;
+import { SparkError, parseNativeResult, type Availability } from "@legendapp/spark-desktop-app/src/contracts";
+import { dragOptions, dragSource, dragDrop, dragEnd, dragPosition, type DragPayload, type DragOptions, type DragOverEvent, type DropEvent, type DragEndEvent } from "./contracts";
+export type { DragPayload, DragOptions, DragOperation, DragOverEvent, DropEvent, DragEndEvent } from "./contracts";
+export interface DragDropViewProps extends ViewProps, DragOptions {
+  disabled?: boolean;
+  source?: DragPayload;
+  onDrop?: (event: DropEvent) => void;
+  onDragEnter?: (event: DropEvent) => void;
+  onDragOver?: (event: DragOverEvent) => void;
+  onDragLeave?: () => void;
+  onDragEnd?: (event: DragEndEvent) => void;
+  onError?: (error: SparkError) => void;
+}
+export function getDragDropAvailability(): Availability {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") return { available: false, reason: "unsupported-platform" };
+  return UIManager.hasViewManagerConfig("DesktopDragView") ? { available: true } : { available: false, reason: "missing-module" };
+}
+type Event = NativeSyntheticEvent<{ json: string }>;
+export function DragDropView({ source, sourceOperations, acceptedOperations, acceptedTypes, disabled = false, onDrop, onDragEnter, onDragOver, onDragLeave, onDragEnd, onError = console.error, ...props }: DragDropViewProps) {
+  const optionsJson = dragOptions({ sourceOperations, acceptedOperations, acceptedTypes });
+  const sourceJson = source === undefined ? "" : JSON.stringify(dragSource(source, Platform.OS));
+  if (typeof disabled !== "boolean") throw new SparkError("E_INVALID_ARGUMENT", "Expected disabled to be a boolean");
+  for (const handler of [onDrop, onDragEnter, onDragOver, onDragLeave, onDragEnd, onError]) if (handler !== undefined && typeof handler !== "function") throw new SparkError("E_INVALID_ARGUMENT", "Expected a drag event callback");
+  const availability = getDragDropAvailability();
+  const [failed, setFailed] = useState(false);
+  const mounted = useRef(false), reported = useRef<string | undefined>(undefined);
+  useLayoutEffect(() => { mounted.current = true; return () => { mounted.current = false; }; }, []);
+  const unavailable = !availability.available ? availability.reason : undefined;
+  useEffect(() => {
+    if (unavailable && reported.current !== unavailable) {
+      reported.current = unavailable;
+      onError(new SparkError(unavailable === "unsupported-platform" ? "E_UNSUPPORTED_PLATFORM" : "E_MODULE_UNAVAILABLE", "Drag and drop is unavailable"));
+    }
+  }, [unavailable, onError]);
+  function receive<T>(event: Event, parse: (json: string) => T, handler?: (value: T) => void) {
+    if (!mounted.current || disabled || failed) return;
+    let value: T;
+    try { value = parse(event?.nativeEvent?.json); }
+    catch (cause) { onError(cause instanceof SparkError ? cause : new SparkError("E_INVALID_DATA", "Invalid native drag event", { cause })); return; }
+    handler?.(value);
+  }
+  function error(event: Event) {
+    if (!mounted.current || failed) return;
+    let value: { message: string; unavailable: boolean };
+    try { value = parseNativeResult(event?.nativeEvent?.json, (value): value is { message: string; unavailable: boolean } => !!value && typeof value === "object" && "message" in value && typeof value.message === "string" && "unavailable" in value && typeof value.unavailable === "boolean"); }
+    catch (cause) { onError(cause as SparkError); return; }
+    if (value.unavailable) setFailed(true);
+    onError(new SparkError(value.unavailable ? "E_UNAVAILABLE" : "E_NATIVE", value.message));
+  }
+  if (!availability.available || failed) return <View {...props} />;
+  return <NativeView {...props} disabled={disabled} sourceJson={sourceJson} optionsJson={optionsJson} onError={error}
+    onDrop={event => receive(event, json => dragDrop(json, Platform.OS), onDrop)}
+    onDragEnter={event => receive(event, json => dragDrop(json, Platform.OS), onDragEnter)}
+    onDragOver={onDragOver ? event => receive(event, dragPosition, onDragOver) : undefined}
+    onDragLeave={() => { if (mounted.current && !disabled && !failed) onDragLeave?.(); }}
+    onDragEnd={event => receive(event, dragEnd, onDragEnd)} />;
 }