@legendapp/spark 0.0.1-next.2

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

@@ -0,0 +1,44 @@
+{
+  "name": "@legendapp/spark-drag-drop",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "main": "src/index.tsx",
+  "react-native": "src/index.tsx",
+  "files": [
+    "src",
+    "macos",
+    "*.podspec",
+    "windows",
+    "react-native.config.js"
+  ],
+  "peerDependencies": {
+    "react": "19.1.4",
+    "react-native": "0.81.6"
+  },
+  "codegenConfig": {
+    "name": "RNDesktopDragSpec",
+    "type": "components",
+    "jsSrcsDir": "src",
+    "ios": {
+      "componentProvider": {
+        "DesktopDragView": "RNDesktopDragView"
+      }
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "nativeModules": [],
+    "pod": "RNDesktopDrag",
+    "platforms": [
+      "macos",
+      "windows"
+    ],
+    "requires": [
+      "@legendapp/spark-desktop-app"
+    ]
+  },
+  "dependencies": {
+    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+  },
+  "private": true
+}

package/vendor/node_modules/@legendapp/spark-drag-drop/react-native.config.js

@@ -0,0 +1,6 @@
+// Expo Desktop currently invokes the Apple autolinker with --platform ios.
+// Its generated Podfile identifies macOS explicitly; ordinary iOS apps use Expo backends.
+module.exports = { dependency: { platforms: {
+  ios: process.env.SPARK_DESKTOP_AUTOLINK === "macos" ? {} : null,
+  android: null,
+} } };

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

@@ -0,0 +1,16 @@
+import type { HostComponent, ViewProps } from "react-native";
+import type { DirectEventHandler, WithDefault } from "react-native/Libraries/Types/CodegenTypes";
+import codegenNativeComponent from "react-native/Libraries/Utilities/codegenNativeComponent";
+type Payload = Readonly<{ json: string }>;
+export interface NativeProps extends ViewProps {
+  sourceJson?: string;
+  optionsJson?: string;
+  disabled?: WithDefault<boolean, false>;
+  onUnavailable?: DirectEventHandler<Payload>;
+  onDrop?: DirectEventHandler<Payload>;
+  onDragEnter?: DirectEventHandler<Payload>;
+  onDragOver?: DirectEventHandler<Payload>;
+  onDragLeave?: DirectEventHandler<Payload>;
+  onDragEnd?: DirectEventHandler<Payload>;
+}
+export default codegenNativeComponent<NativeProps>("DesktopDragView") as HostComponent<NativeProps>;

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

@@ -0,0 +1,28 @@
+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[];
+  /** Built-ins: files, text, urls. Custom types use MIME names. Default: built-ins. */
+  acceptedTypes?: 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) {
+  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");
+  }
+  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");
+  }
+  return JSON.stringify({ sourceOperations: options.sourceOperations ?? ["copy"], acceptedOperations: options.acceptedOperations ?? ["copy"], acceptedTypes: types });
+}

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

@@ -0,0 +1,17 @@
+import React, { useCallback, useState } from "react";
+import { Platform, Text, 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} />;
+}

package/vendor/node_modules/@legendapp/spark-drag-drop/windows/ExperimentalFeatures.props

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <PropertyGroup Label="Microsoft.ReactNative Experimental Features">
+    <!--
+      Required for building a New Architecture project.
+
+      Library projects can change this value to test against Old and New
+      Architectures when building the library project's local sln file.
+
+      Otherwise this value will be decided by the consuming RNW app.
+
+      See https://microsoft.github.io/react-native-windows/docs/new-architecture
+    -->
+    <RnwNewArch>true</RnwNewArch>
+
+    <!--
+      Changes compilation to assume use of Microsoft.ReactNative NuGet packages
+      instead of building the framework from source. Defaults to true.
+
+      This is set during library project creation and is used when building
+      the library project's local sln file.
+
+      Otherwise this value will be decided by the consuming RNW app.
+
+      See https://microsoft.github.io/react-native-windows/docs/nuget
+    -->
+    <UseExperimentalNuget>true</UseExperimentalNuget>
+
+    <ReactExperimentalFeaturesSet>true</ReactExperimentalFeaturesSet>
+  </PropertyGroup>
+
+</Project>

package/vendor/node_modules/@legendapp/spark-drag-drop/windows/LICENSE

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+
+Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+
+Portions derived from React Native:
+
+Copyright (c) 2015-present, Facebook, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/node_modules/@legendapp/spark-drag-drop/windows/SparkDragDrop/ReactPackageProvider.cpp

@@ -0,0 +1,21 @@
+#include "pch.h"
+
+#include "ReactPackageProvider.h"
+#if __has_include("ReactPackageProvider.g.cpp")
+#include "ReactPackageProvider.g.cpp"
+#endif
+
+#include "SparkDragDrop.h"
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::SparkDragDrop::implementation
+{
+
+void ReactPackageProvider::CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept
+{
+  AddAttributedModules(packageBuilder, true);
+  winrt::SparkDragDrop::Register(packageBuilder);
+}
+
+} // namespace winrt::SparkDragDrop::implementation

package/vendor/node_modules/@legendapp/spark-drag-drop/windows/SparkDragDrop/ReactPackageProvider.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "ReactPackageProvider.g.h"
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::SparkDragDrop::implementation
+{
+
+struct ReactPackageProvider : ReactPackageProviderT<ReactPackageProvider>
+{
+  ReactPackageProvider() = default;
+
+  void CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept;
+};
+
+} // namespace winrt::SparkDragDrop::implementation
+
+namespace winrt::SparkDragDrop::factory_implementation
+{
+
+struct ReactPackageProvider : ReactPackageProviderT<ReactPackageProvider, implementation::ReactPackageProvider> {};
+
+} // namespace winrt::SparkDragDrop::factory_implementation

package/vendor/node_modules/@legendapp/spark-drag-drop/windows/SparkDragDrop/ReactPackageProvider.idl

@@ -0,0 +1,9 @@
+namespace SparkDragDrop
+{
+  [webhosthidden]
+  [default_interface]
+  runtimeclass ReactPackageProvider : Microsoft.ReactNative.IReactPackageProvider
+  {
+    ReactPackageProvider();
+  };
+}

package/vendor/node_modules/@legendapp/spark-drag-drop/windows/SparkDragDrop/SparkDragDrop.cpp

@@ -0,0 +1,2 @@
+#include "pch.h"
+#include "SparkDragDrop.h"

package/vendor/node_modules/@legendapp/spark-drag-drop/windows/SparkDragDrop/SparkDragDrop.def

@@ -0,0 +1,3 @@
+EXPORTS
+DllCanUnloadNow = WINRT_CanUnloadNow                    PRIVATE
+DllGetActivationFactory = WINRT_GetActivationFactory    PRIVATE

package/vendor/node_modules/@legendapp/spark-drag-drop/windows/SparkDragDrop/SparkDragDrop.h

@@ -0,0 +1,209 @@
+#pragma once
+#include "NativeModules.h"
+#include <SparkComponentGeometry.h>
+#include <cmath>
+#include <map>
+#include <memory>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+#include <winrt/Microsoft.ReactNative.Composition.Input.h>
+#include <winrt/Microsoft.UI.Input.DragDrop.h>
+#include <winrt/Microsoft.UI.Content.h>
+#include <winrt/Windows.ApplicationModel.DataTransfer.h>
+#include <winrt/Windows.Storage.h>
+#include <winrt/Windows.Data.Json.h>
+namespace winrt::SparkDragDrop {
+namespace React = Microsoft::ReactNative;
+namespace Composition = Microsoft::ReactNative::Composition;
+namespace Drag = Microsoft::UI::Input::DragDrop;
+namespace Transfer = Windows::ApplicationModel::DataTransfer;
+namespace Json = Windows::Data::Json;
+using Operation = Transfer::DataPackageOperation;
+inline Operation ParseOperation(hstring const &name) { return name == L"move" ? Operation::Move : name == L"link" ? Operation::Link : name == L"copy" ? Operation::Copy : Operation::None; }
+inline hstring OperationName(Operation value) { return value == Operation::Move ? L"move" : value == Operation::Link ? L"link" : value == Operation::Copy ? L"copy" : L"none"; }
+inline Json::JsonArray Strings(std::initializer_list<wchar_t const *> values) { Json::JsonArray result; for (auto value : values) result.Append(Json::JsonValue::CreateStringValue(value)); return result; }
+using Point = Windows::Foundation::Point;
+using Windows::Foundation::IAsyncAction;
+using Windows::Foundation::IAsyncOperation;
+struct Props : implements<Props, React::IComponentProps> {
+  React::ViewProps view{nullptr}; std::string source, options = "{}"; bool disabled = false;
+  void SetProp(uint32_t, hstring const &name, React::IJSValueReader const &reader) noexcept {
+    if (name == L"sourceJson") React::ReadValue(reader, source); else if (name == L"optionsJson") React::ReadValue(reader, options); else if (name == L"disabled") React::ReadValue(reader, disabled);
+  }
+};
+struct DragView;
+struct RootState {
+  apartment_context ui;
+  weak_ref<Composition::RootComponentView> root;
+  Drag::DragDropManager manager{nullptr}; event_token requested{};
+  std::map<int32_t, weak_ref<DragView>> views;
+  ~RootState() { if (manager) try { manager.TargetRequested(requested); } catch (...) {} }
+  static React::ComponentView Find(React::ComponentView const &view, int64_t tag) {
+    if (view.Tag() == tag) return view;
+    for (auto const &child : view.Children()) if (auto found = Find(child, tag)) return found;
+    return nullptr;
+  }
+  com_ptr<DragView> Target(Point point);
+};
+struct DragView : implements<DragView, Windows::Foundation::IInspectable> {
+  weak_ref<Composition::ViewComponentView> view;
+  React::EventEmitter emitter{nullptr};
+  std::shared_ptr<RootState> root;
+  std::string source, failure, options = "{}";
+  bool disabled = false, pressed = false, dragging = false, mounted = false;
+  Point origin{};
+  Drag::DragOperation operation{nullptr};
+  void Emit(hstring const &event, Json::JsonObject const &value = {}) {
+    if (!emitter || !mounted) return;
+    const auto json = value.Stringify();
+    emitter.DispatchEvent(event, [json](React::IJSValueWriter const &writer) { writer.WriteObjectBegin(); writer.WritePropertyName(L"json"); writer.WriteString(json); writer.WriteObjectEnd(); });
+  }
+  Point Local(Point point) {
+    auto strong = view.get(); if (!strong) return {};
+    auto rect = strong.as<ISparkComponentGeometry>()->SparkClientRect(); auto scale = strong.LayoutMetrics().PointScaleFactor; if (scale <= 0) scale = 1;
+    return {point.X - rect.left / scale, point.Y - rect.top / scale};
+  }
+  Json::JsonObject Options() { return Json::JsonObject::Parse(to_hstring(options.empty() ? "{}" : options)); }
+  Json::JsonArray Types() { return Options().GetNamedArray(L"acceptedTypes", Strings({L"files", L"text", L"urls"})); }
+  Operation Accept(Drag::DragInfo const &info) {
+    if (!mounted || disabled) return Operation::None;
+    auto data = info.Data(); bool supported = false;
+    for (auto const &item : Types()) {
+      auto type = item.GetString();
+      auto format = type == L"files" ? Transfer::StandardDataFormats::StorageItems() : type == L"text" ? Transfer::StandardDataFormats::Text() : type == L"urls" ? Transfer::StandardDataFormats::WebLink() : type;
+      if (data.Contains(format)) { supported = true; break; }
+    }
+    if (!supported) return Operation::None;
+    for (auto const &name : Options().GetNamedArray(L"acceptedOperations", Strings({L"copy"}))) {
+      auto operation = ParseOperation(name.GetString()); if ((info.AllowedOperations() & operation) != Operation::None) return operation;
+    }
+    return Operation::None;
+  }
+  void Fail(hresult_error const &error) { failure = to_string(error.message()); Json::JsonObject value; value.SetNamedValue(L"message", Json::JsonValue::CreateStringValue(error.message())); Emit(L"unavailable", value); }
+  fire_and_forget Start(Microsoft::UI::Input::PointerPoint point, Composition::Input::Pointer pointer) {
+    auto keepAlive = get_strong();
+    Operation resultOperation = Operation::None;
+    try {
+      if (!root || source.empty() || disabled) throw hresult_canceled();
+      auto session = root;
+      operation = Drag::DragOperation(); Operation allowed = Operation::None;
+      for (auto const &name : Options().GetNamedArray(L"sourceOperations", Strings({L"copy"}))) allowed = allowed | ParseOperation(name.GetString());
+      operation.AllowedOperations(allowed);
+      auto data = operation.Data(); auto payload = Json::JsonObject::Parse(to_hstring(source));
+      data.SetData(L"application/x-spark-drag", box_value(to_hstring(source)));
+      for (auto const &item : payload.GetNamedObject(L"data", Json::JsonObject())) data.SetData(item.Key(), box_value(item.Value().GetString()));
+      if (payload.HasKey(L"text")) data.SetText(payload.GetNamedString(L"text"));
+      if (payload.HasKey(L"urls")) { auto urls = payload.GetNamedArray(L"urls"); if (urls.Size()) data.SetWebLink(Windows::Foundation::Uri(urls.GetStringAt(0))); }
+      if (payload.HasKey(L"files")) {
+        auto items = single_threaded_vector<Windows::Storage::IStorageItem>();
+        for (auto const &entry : payload.GetNamedArray(L"files")) {
+          auto path = entry.GetString(); auto attributes = GetFileAttributesW(path.c_str()); if (attributes == INVALID_FILE_ATTRIBUTES) throw_last_error();
+          if (attributes & FILE_ATTRIBUTE_DIRECTORY) items.Append(co_await Windows::Storage::StorageFolder::GetFolderFromPathAsync(path));
+          else items.Append(co_await Windows::Storage::StorageFile::GetFileFromPathAsync(path));
+        }
+        data.SetStorageItems(items);
+      }
+      if (mounted && !disabled && root == session) resultOperation = co_await operation.StartAsync(session->manager, point);
+    } catch (hresult_error const &error) { /* Failed or cancelled sources report accepted=false. */ }
+    if (auto strong = view.get()) strong.ReleasePointerCapture(pointer);
+    if (operation) { try { operation.Close(); } catch (...) {} operation = nullptr; }
+    dragging = false; Json::JsonObject result; result.SetNamedValue(L"accepted", Json::JsonValue::CreateBooleanValue(resultOperation != Operation::None)); result.SetNamedValue(L"operation", Json::JsonValue::CreateStringValue(OperationName(resultOperation))); Emit(L"dragEnd", result);
+  }
+  void Close(bool destroy = false) noexcept {
+    mounted = false; pressed = false;
+    if (root) { if (auto strong = view.get()) root->views.erase(strong.Tag()); root.reset(); }
+    if (operation) try { operation.Close(); } catch (...) {}
+    if (destroy) emitter = nullptr;
+  }
+};
+inline com_ptr<DragView> RootState::Target(Point point) {
+  auto strong = root.get(); if (!strong) return nullptr;
+  float x = 0, y = 0; auto tag = strong.as<ISparkComponentGeometry>()->SparkHitTest(point.X, point.Y, &x, &y);
+  if (tag < 0) return nullptr;
+  auto target = Find(strong, tag);
+  while (target) {
+    auto found = views.find(target.Tag());
+    if (found != views.end()) if (auto state = found->second.get(); state && state->mounted && !state->disabled) return state;
+    target = target.Parent();
+  }
+  return nullptr;
+}
+inline IAsyncOperation<Json::JsonObject> Payload(Drag::DragInfo info, Point point, Json::JsonArray types, Operation operation) {
+  auto data = info.Data(); Json::JsonObject result;
+  if (data.Contains(L"application/x-spark-drag")) result = Json::JsonObject::Parse(unbox_value<hstring>(co_await data.GetDataAsync(L"application/x-spark-drag")));
+  else {
+    if (data.Contains(Transfer::StandardDataFormats::Text())) result.SetNamedValue(L"text", Json::JsonValue::CreateStringValue(co_await data.GetTextAsync()));
+    if (data.Contains(Transfer::StandardDataFormats::StorageItems())) { Json::JsonArray files; for (auto const &item : co_await data.GetStorageItemsAsync()) files.Append(Json::JsonValue::CreateStringValue(item.Path())); result.SetNamedValue(L"files", files); }
+    if (data.Contains(Transfer::StandardDataFormats::WebLink())) { Json::JsonArray urls; urls.Append(Json::JsonValue::CreateStringValue((co_await data.GetWebLinkAsync()).AbsoluteUri())); result.SetNamedValue(L"urls", urls); }
+  }
+  Json::JsonObject custom;
+  for (auto const &entry : types) { auto type = entry.GetString(); if (std::wstring(type).find(L'/') != std::wstring::npos && data.Contains(type)) custom.SetNamedValue(type, Json::JsonValue::CreateStringValue(unbox_value<hstring>(co_await data.GetDataAsync(type)))); }
+  result.SetNamedValue(L"data", custom);
+  result.SetNamedValue(L"operation", Json::JsonValue::CreateStringValue(OperationName(operation)));
+  result.SetNamedValue(L"x", Json::JsonValue::CreateNumberValue(point.X)); result.SetNamedValue(L"y", Json::JsonValue::CreateNumberValue(point.Y)); co_return result;
+}
+struct DropTarget : implements<DropTarget, Drag::IDropOperationTarget> {
+  std::shared_ptr<RootState> root; weak_ref<DragView> current;
+  DropTarget(std::shared_ptr<RootState> value) : root(std::move(value)) {}
+  IAsyncOperation<Operation> OverAsync(Drag::DragInfo info, Drag::DragUIOverride) {
+    auto keepAlive = get_strong(); co_await root->ui;
+    try {
+      auto target = root->Target(info.Position());
+      auto operation = target ? target->Accept(info) : Operation::None;
+      if (operation == Operation::None) target = nullptr;
+      auto previous = current.get();
+      if (target != previous) {
+        if (previous) previous->Emit(L"dragLeave"); current = target ? target->get_weak() : weak_ref<DragView>{};
+        if (target) { auto payload = co_await Payload(info, target->Local(info.Position()), target->Types(), operation); if (target->mounted && !target->disabled && current.get() == target) target->Emit(L"dragEnter", payload); }
+      }
+      if (!target || current.get() != target || target->Accept(info) != operation) co_return Operation::None;
+      const auto point = target->Local(info.Position()); Json::JsonObject over;
+      over.SetNamedValue(L"x", Json::JsonValue::CreateNumberValue(point.X)); over.SetNamedValue(L"y", Json::JsonValue::CreateNumberValue(point.Y));
+      over.SetNamedValue(L"operation", Json::JsonValue::CreateStringValue(OperationName(operation))); target->Emit(L"dragOver", over);
+      co_return operation;
+    } catch (...) { co_return Operation::None; }
+  }
+  IAsyncOperation<Operation> EnterAsync(Drag::DragInfo info, Drag::DragUIOverride ui) { return OverAsync(info, ui); }
+  IAsyncAction LeaveAsync(Drag::DragInfo) { auto keepAlive = get_strong(); co_await root->ui; if (auto previous = current.get()) previous->Emit(L"dragLeave"); current = {}; co_return; }
+  IAsyncOperation<Operation> DropAsync(Drag::DragInfo info) {
+    auto keepAlive = get_strong(); co_await root->ui;
+    try {
+      auto target = root->Target(info.Position());
+      auto operation = target ? target->Accept(info) : Operation::None; if (operation == Operation::None) co_return operation;
+      auto payload = co_await Payload(info, target->Local(info.Position()), target->Types(), operation);
+      if (target->Accept(info) != operation) co_return Operation::None;
+      target->Emit(L"drop", payload); current = {}; co_return operation;
+    } catch (...) { co_return Operation::None; }
+  }
+};
+inline std::shared_ptr<RootState> ForRoot(Composition::RootComponentView const &root) {
+  static thread_local std::map<int32_t, std::weak_ptr<RootState>> roots;
+  if (auto existing = roots[root.Tag()].lock()) if (existing->root.get() == root) return existing;
+  auto state = std::make_shared<RootState>(); state->root = root; state->manager = Drag::DragDropManager::GetForIsland(root.ReactNativeIsland().Island());
+  // Fail at mount if an unpatched runtime was selected, instead of crashing on a drop.
+  root.as<ISparkComponentGeometry>();
+  state->requested = state->manager.TargetRequested([weak = std::weak_ptr(state)](auto const &, auto const &args) { if (auto state = weak.lock()) args.SetTarget(make<DropTarget>(state)); });
+  roots[root.Tag()] = state; return state;
+}
+inline void Register(React::IReactPackageBuilder const &package) {
+  package.as<React::IReactPackageBuilderFabric>().AddViewComponent(L"DesktopDragView", [](React::IReactViewComponentBuilder const &builder) {
+    builder.SetCreateProps([](React::ViewProps const &view, React::IComponentProps const &previous) { auto props = make_self<Props>(); if (previous) { auto old = get_self<Props>(previous); props->source = old->source; props->options = old->options; props->disabled = old->disabled; } props->view = view; return props.as<React::IComponentProps>(); });
+    builder.as<Composition::IReactCompositionViewComponentBuilder>().SetViewComponentViewInitializer([](Composition::ViewComponentView const &view) {
+      auto state = make_self<DragView>(); state->view = view; view.UserData(state.as<Windows::Foundation::IInspectable>()); auto weak = state->get_weak();
+      view.Mounted([weak](auto const &, React::ComponentView const &) { if (auto self = weak.get()) try { self->mounted = true; auto view = self->view.get(); self->root = ForRoot(view.Root()); self->root->views[view.Tag()] = self->get_weak(); } catch (hresult_error const &error) { self->Fail(error); } });
+      view.Unmounted([weak](auto const &, auto const &) { if (auto self = weak.get()) self->Close(); });
+      view.Destroying([weak](auto const &, auto const &) { if (auto self = weak.get()) self->Close(true); });
+      view.PointerPressed([weak](auto const &, Composition::Input::PointerRoutedEventArgs const &args) { if (auto self = weak.get(); self && !args.Handled() && !self->disabled && !self->source.empty()) { auto point = args.GetCurrentPoint(self->view.get().Tag()); self->pressed = point.Properties().IsLeftButtonPressed(); self->origin = point.Position(); } });
+      view.PointerReleased([weak](auto const &, auto const &) { if (auto self = weak.get()) self->pressed = false; });
+      view.PointerMoved([weak](auto const &, Composition::Input::PointerRoutedEventArgs const &args) {
+        if (auto self = weak.get(); self && self->mounted && self->root && self->pressed && !self->dragging && !self->disabled && !args.Handled()) {
+          auto view = self->view.get(); auto point = args.GetCurrentPoint(view.Tag()); if (!point.Properties().IsLeftButtonPressed()) { self->pressed = false; return; }
+          if (std::hypot(point.Position().X - self->origin.X, point.Position().Y - self->origin.Y) < 6) return;
+          self->dragging = true; self->pressed = false; args.Handled(true); view.CapturePointer(args.Pointer()); self->Start(point.Inner(), args.Pointer());
+        }
+      });
+    });
+    builder.SetUpdatePropsHandler([](React::ComponentView const &view, React::IComponentProps const &props, React::IComponentProps const &) { auto state = get_self<DragView>(view.UserData()); auto value = get_self<Props>(props); state->source = value->source; state->options = value->options; state->disabled = value->disabled; });
+    builder.SetUpdateEventEmitterHandler([](React::ComponentView const &view, React::EventEmitter const &emitter) { auto state = get_self<DragView>(view.UserData()); state->emitter = emitter; if (!state->failure.empty()) { Json::JsonObject error; error.SetNamedValue(L"message", Json::JsonValue::CreateStringValue(to_hstring(state->failure))); state->Emit(L"unavailable", error); } });
+  });
+}
+}

package/vendor/node_modules/@legendapp/spark-drag-drop/windows/SparkDragDrop/SparkDragDrop.vcxproj

@@ -0,0 +1,143 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- This project was created with react-native-windows 0.81.35 -->
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(SolutionDir)\ExperimentalFeatures.props" Condition="Exists('$(SolutionDir)\ExperimentalFeatures.props')" />
+  <PropertyGroup Label="Globals">
+    <CppWinRTOptimized>true</CppWinRTOptimized>
+    <MinimalCoreWin>true</MinimalCoreWin>
+    <ProjectGuid>{04029872-C07C-4A4E-B48D-BE7ABF483554}</ProjectGuid>
+    <ProjectName>SparkDragDrop</ProjectName>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>SparkDragDrop</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+    <DefaultLanguage>en-US</DefaultLanguage>
+    <MinimumVisualStudioVersion>17.0</MinimumVisualStudioVersion>
+    <AppxPackage>false</AppxPackage>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Label="ReactNativeWindowsProps">
+    <ReactNativeWindowsDir Condition="'$(ReactNativeWindowsDir)' == ''">$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), 'node_modules\react-native-windows\package.json'))\node_modules\react-native-windows\</ReactNativeWindowsDir>
+    <RunAutolinkCheck>false</RunAutolinkCheck>
+  </PropertyGroup>
+  <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.WindowsSdk.Default.props" />
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v145</PlatformToolset>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="ReactNativeWindowsPropertySheets">
+    <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.props" Condition="Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.props')" />
+  </ImportGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
+      <PrecompiledHeaderOutputFile>$(IntDir)pch.pch</PrecompiledHeaderOutputFile>
+      <WarningLevel>Level4</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <AdditionalOptions>%(AdditionalOptions) /bigobj</AdditionalOptions>
+      <DisableSpecificWarnings>4453;28204</DisableSpecificWarnings>
+      <PreprocessorDefinitions>_WINRT_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalUsingDirectories>$(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories)</AdditionalUsingDirectories>
+      <AdditionalIncludeDirectories>
+        $(MSBuildThisFileDirectory);
+        %(AdditionalIncludeDirectories)
+      </AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>shell32.lib;user32.lib;windowsapp.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <SubSystem>Console</SubSystem>
+      <GenerateWindowsMetadata>true</GenerateWindowsMetadata>
+      <ModuleDefinitionFile>SparkDragDrop.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'">
+    <ClCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemGroup>
+    <ClInclude Include="SparkDragDrop.h" />
+    <ClInclude Include="ReactPackageProvider.h">
+      <DependentUpon>ReactPackageProvider.idl</DependentUpon>
+    </ClInclude>
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="pch.h" />
+    <ClInclude Include="targetver.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="SparkDragDrop.cpp" />
+    <ClCompile Include="pch.cpp">
+      <PrecompiledHeader>Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="ReactPackageProvider.cpp">
+      <DependentUpon>ReactPackageProvider.idl</DependentUpon>
+    </ClCompile>
+    <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <Midl Include="ReactPackageProvider.idl" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="SparkDragDrop.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ReactNativeWindowsTargets">
+    <Import Project="$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.targets" Condition="Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.targets')" />
+  </ImportGroup>
+  <ItemGroup>
+  </ItemGroup>
+  <Target Name="EnsureReactNativeWindowsTargets" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references targets in your node_modules\react-native-windows folder. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.props')" Text="$([System.String]::Format('$(ErrorText)', '$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.props'))" />
+    <Error Condition="!Exists('$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(ReactNativeWindowsDir)\PropertySheets\External\Microsoft.ReactNative.CppLib.targets'))" />
+  </Target>
+</Project>