@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-clipboard/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-clipboard/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-clipboard/windows/SparkClipboard/ReactPackageProvider.cpp

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

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/ReactPackageProvider.h

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

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/ReactPackageProvider.idl

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

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/SparkClipboard.cpp

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

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/SparkClipboard.def

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

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/SparkClipboard.h

@@ -0,0 +1,119 @@
+#pragma once
+#include "NativeModules.h"
+#include <winrt/Windows.ApplicationModel.DataTransfer.h>
+#include <winrt/Windows.Data.Json.h>
+#include <winrt/Windows.Data.Html.h>
+#include <winrt/Windows.Storage.h>
+#include <winrt/Windows.Storage.Streams.h>
+#include <winrt/Windows.Graphics.Imaging.h>
+#include <winrt/Windows.Security.Cryptography.h>
+#include <richedit.h>
+#include <algorithm>
+namespace winrt::SparkClipboard {
+namespace React = Microsoft::ReactNative;
+namespace Transfer = Windows::ApplicationModel::DataTransfer;
+namespace Json = Windows::Data::Json;
+namespace Streams = Windows::Storage::Streams;
+namespace Imaging = Windows::Graphics::Imaging;
+using Windows::Security::Cryptography::CryptographicBuffer;
+inline hstring PlainRTF(hstring const &rtf) {
+  static const auto library = LoadLibraryW(L"Msftedit.dll"); if (!library) throw_last_error();
+  auto window = CreateWindowExW(0, MSFTEDIT_CLASS, L"", ES_MULTILINE, 0, 0, 0, 0, HWND_MESSAGE, nullptr, GetModuleHandleW(nullptr), nullptr);
+  if (!window) throw_last_error();
+  struct Input { std::string bytes; size_t offset = 0; } input{to_string(rtf)};
+  EDITSTREAM stream{}; stream.dwCookie = reinterpret_cast<DWORD_PTR>(&input);
+  stream.pfnCallback = [](DWORD_PTR cookie, LPBYTE buffer, LONG size, LONG *read) -> DWORD {
+    auto &value = *reinterpret_cast<Input *>(cookie); *read = static_cast<LONG>(std::min(static_cast<size_t>(size), value.bytes.size() - value.offset));
+    memcpy(buffer, value.bytes.data() + value.offset, *read); value.offset += *read; return 0;
+  };
+  SendMessageW(window, EM_STREAMIN, SF_RTF, reinterpret_cast<LPARAM>(&stream));
+  auto size = GetWindowTextLengthW(window); std::wstring text(size + 1, L'\0'); GetWindowTextW(window, text.data(), size + 1); DestroyWindow(window);
+  if (stream.dwError) throw hresult_invalid_argument(L"Invalid clipboard RTF"); text.resize(size); return hstring(text);
+}
+inline hstring HTML(hstring const &text) {
+  std::wstring value = L"<div>";
+  for (auto c : text) { switch(c) { case L'&': value += L"&amp;"; break; case L'<': value += L"&lt;"; break; case L'>': value += L"&gt;"; break; case L'\n': value += L"<br>"; break; default: value += c; } }
+  return hstring(value + L"</div>");
+}
+REACT_MODULE(SparkClipboard, L"NativeDesktopClipboard")
+struct SparkClipboard {
+  React::ReactContext context;
+  REACT_INIT(Initialize) void Initialize(React::ReactContext const &value) noexcept { context = value; }
+  static fire_and_forget Invoke(std::string method, std::string encoded, React::ReactPromise<std::string> promise) {
+    try {
+      auto args = Json::JsonObject::Parse(to_hstring(encoded));
+      if (method == "write" || method == "setString" || method == "writeText") {
+        if (method != "write") {
+          Json::JsonObject content; content.SetNamedValue(args.GetNamedString(L"format", L"plainText") == L"html" ? L"html" : L"text", args.GetNamedValue(L"text")); args = content;
+        }
+        Transfer::DataPackage data;
+        if (args.HasKey(L"text")) data.SetText(args.GetNamedString(L"text"));
+        if (args.HasKey(L"html")) {
+          auto html = args.GetNamedString(L"html"); data.SetHtmlFormat(Transfer::HtmlFormatHelper::CreateHtmlFormat(html));
+          if (!args.HasKey(L"text")) data.SetText(Windows::Data::Html::HtmlUtilities::ConvertToText(html));
+        }
+        if (args.HasKey(L"rtf")) { data.SetRtf(args.GetNamedString(L"rtf")); if (!args.HasKey(L"text") && !args.HasKey(L"html")) data.SetText(PlainRTF(args.GetNamedString(L"rtf"))); }
+        if (args.HasKey(L"files")) {
+          auto items = single_threaded_vector<Windows::Storage::IStorageItem>();
+          for (auto const &entry : args.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); data.RequestedOperation(Transfer::DataPackageOperation::Copy);
+        }
+        if (args.HasKey(L"imagePNG")) {
+          auto bytes = CryptographicBuffer::DecodeFromBase64String(args.GetNamedString(L"imagePNG"));
+          Streams::InMemoryRandomAccessStream stream; co_await stream.WriteAsync(bytes); stream.Seek(0);
+          auto decoder = co_await Imaging::BitmapDecoder::CreateAsync(stream);
+          if (decoder.DecoderInformation().CodecId() != Imaging::BitmapDecoder::PngDecoderId()) throw hresult_invalid_argument(L"Clipboard image must be PNG");
+          data.SetBitmap(Streams::RandomAccessStreamReference::CreateFromStream(stream));
+        }
+        if (args.Size() == 0) Transfer::Clipboard::Clear();
+        else { Transfer::Clipboard::SetContent(data); Transfer::Clipboard::Flush(); }
+        promise.Resolve("null");
+      } else if (method == "clear") { Transfer::Clipboard::Clear(); promise.Resolve("null"); }
+      else {
+        auto data = Transfer::Clipboard::GetContent();
+        const bool text = data.Contains(Transfer::StandardDataFormats::Text()), html = data.Contains(Transfer::StandardDataFormats::Html()), rtf = data.Contains(Transfer::StandardDataFormats::Rtf());
+        if (method == "hasString" || method == "hasText") promise.Resolve((text || (method == "hasString" && (html || rtf))) ? "true" : "false");
+        else if (method == "formats") { Json::JsonArray formats; for (auto const &format : data.AvailableFormats()) formats.Append(Json::JsonValue::CreateStringValue(format)); promise.Resolve(to_string(formats.Stringify())); }
+        else if (method == "getString" || method == "readText") {
+          hstring value; const bool preferHTML = args.GetNamedString(L"format", L"plainText") == L"html";
+          if (method == "getString" && preferHTML && html) value = Transfer::HtmlFormatHelper::GetStaticFragment(co_await data.GetHtmlFormatAsync());
+          else {
+            if (text) value = co_await data.GetTextAsync();
+            else if (method == "getString" && html) value = Windows::Data::Html::HtmlUtilities::ConvertToText(Transfer::HtmlFormatHelper::GetStaticFragment(co_await data.GetHtmlFormatAsync()));
+            else if (method == "getString" && rtf) value = PlainRTF(co_await data.GetRtfAsync());
+            if (preferHTML && !value.empty()) value = HTML(value);
+          }
+          promise.Resolve(to_string(Json::JsonValue::CreateStringValue(value).Stringify()));
+        } else if (method == "read") {
+          Json::JsonObject result;
+          if (text) result.SetNamedValue(L"text", Json::JsonValue::CreateStringValue(co_await data.GetTextAsync()));
+          if (html) result.SetNamedValue(L"html", Json::JsonValue::CreateStringValue(Transfer::HtmlFormatHelper::GetStaticFragment(co_await data.GetHtmlFormatAsync())));
+          if (rtf) result.SetNamedValue(L"rtf", Json::JsonValue::CreateStringValue(co_await data.GetRtfAsync()));
+          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::Bitmap())) {
+            auto reference = co_await data.GetBitmapAsync(); auto stream = co_await reference.OpenReadAsync();
+            auto decoder = co_await Imaging::BitmapDecoder::CreateAsync(stream);
+            auto bitmap = co_await decoder.GetSoftwareBitmapAsync(Imaging::BitmapPixelFormat::Bgra8, Imaging::BitmapAlphaMode::Premultiplied);
+            Streams::InMemoryRandomAccessStream output; auto encoder = co_await Imaging::BitmapEncoder::CreateAsync(Imaging::BitmapEncoder::PngEncoderId(), output);
+            encoder.SetSoftwareBitmap(bitmap); co_await encoder.FlushAsync(); output.Seek(0);
+            if (output.Size() > UINT32_MAX) throw hresult_invalid_argument(L"Clipboard image is too large");
+            Streams::Buffer bytes(static_cast<uint32_t>(output.Size())); auto read = co_await output.ReadAsync(bytes, bytes.Capacity(), Streams::InputStreamOptions::None);
+            result.SetNamedValue(L"imagePNG", Json::JsonValue::CreateStringValue(CryptographicBuffer::EncodeToBase64String(read)));
+          }
+          promise.Resolve(to_string(result.Stringify()));
+        } else throw hresult_invalid_argument(L"Unsupported Windows clipboard operation");
+      }
+    } catch (hresult_error const &error) { promise.Reject(React::ReactError{"E_CLIPBOARD", to_string(error.message())}); }
+  }
+  REACT_METHOD(call) void call(std::string method, std::string args, React::ReactPromise<std::string> promise) noexcept {
+    context.UIDispatcher().Post([method = std::move(method), args = std::move(args), promise]() { Invoke(method, args, promise); });
+  }
+};
+}

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/SparkClipboard.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>{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}</ProjectGuid>
+    <ProjectName>SparkClipboard</ProjectName>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>SparkClipboard</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>SparkClipboard.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="SparkClipboard.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="SparkClipboard.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="SparkClipboard.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>

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/SparkClipboard.vcxproj.filters

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="targetver.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="resource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="SparkClipboard.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="SparkClipboard.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="SparkClipboard.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/pch.cpp

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

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/pch.h

@@ -0,0 +1,30 @@
+// pch.h : include file for standard system include files,
+// or project specific include files that are used frequently, but
+// are changed infrequently
+//
+
+#pragma once
+
+#include "targetver.h"
+
+#define NOMINMAX 1
+#define WIN32_LEAN_AND_MEAN 1
+#define WINRT_LEAN_AND_MEAN 1
+
+// Windows Header Files
+#include <windows.h>
+#undef GetCurrentTime
+#include <unknwn.h>
+
+// WinRT Header Files
+#include <winrt/base.h>
+#include <CppWinRTIncludes.h>
+#include <winrt/Microsoft.ReactNative.h>
+
+// C RunTime Header Files
+#include <malloc.h>
+#include <memory.h>
+#include <stdlib.h>
+#include <tchar.h>
+
+// Reference additional headers your project requires here

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/resource.h

@@ -0,0 +1,5 @@
+//
+// Microsoft Visual C++ generated include file.
+// Used by SparkClipboard.rc
+
+#pragma once

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard/targetver.h

@@ -0,0 +1,8 @@
+#pragma once
+
+// Including SDKDDKVer.h defines the highest available Windows platform.
+
+// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
+// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.
+
+#include <SDKDDKVer.h>

package/vendor/node_modules/@legendapp/spark-clipboard/windows/SparkClipboard.sln

@@ -0,0 +1,43 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.3.32929.385
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SparkClipboard", "SparkClipboard\SparkClipboard.vcxproj", "{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Debug|ARM64 = Debug|ARM64
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+		Release|ARM64 = Release|ARM64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Debug|x64.ActiveCfg = Debug|x64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Debug|x64.Build.0 = Debug|x64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Debug|x64.Deploy.0 = Debug|x64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Debug|x86.ActiveCfg = Debug|Win32
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Debug|x86.Build.0 = Debug|Win32
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Debug|x86.Deploy.0 = Debug|Win32
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Debug|ARM64.Build.0 = Debug|ARM64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Release|x64.ActiveCfg = Release|x64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Release|x64.Build.0 = Release|x64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Release|x64.Deploy.0 = Release|x64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Release|x86.ActiveCfg = Release|Win32
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Release|x86.Build.0 = Release|Win32
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Release|x86.Deploy.0 = Release|Win32
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Release|ARM64.ActiveCfg = Release|ARM64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Release|ARM64.Build.0 = Release|ARM64
+		{CC5B4458-D7F8-50BD-895D-5956FBCE10C3}.Release|ARM64.Deploy.0 = Release|ARM64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {D43FAD39-F619-437D-BB40-04A3982ACB6A}
+	EndGlobalSection
+EndGlobal

package/vendor/node_modules/@legendapp/spark-context-menu/RNContextMenu.podspec

@@ -0,0 +1,16 @@
+require "json"
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+Pod::Spec.new do |s|
+  s.name = "RNContextMenu"
+  s.version = package["version"]
+  s.summary = "Desktop context-menu"
+  s.license = { :type => "MIT" }
+  s.author = "Legend"
+  s.homepage = "https://legendapp.com"
+  s.source = { :path => "." }
+  s.platforms = { :osx => "14.0" }
+  s.source_files = "macos/**/*.{h,m,mm}"
+  s.dependency "React-Core"
+  s.dependency "ReactCodegen"
+  s.dependency "RNDesktopApp"
+end

package/vendor/node_modules/@legendapp/spark-context-menu/macos/RNContextMenu.h

@@ -0,0 +1,9 @@
+#import <Foundation/Foundation.h>
+#import <RNContextMenuSpec/RNContextMenuSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNContextMenu : NSObject <NativeContextMenuSpec>
+@end
+
+NS_ASSUME_NONNULL_END