@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-notifications/windows/SparkNotifications/SparkNotifications.h

@@ -0,0 +1,132 @@
+#pragma once
+#include "NativeModules.h"
+#include <shobjidl.h>
+#include <shlobj.h>
+#include <propkey.h>
+#include <propvarutil.h>
+#include <filesystem>
+#include <map>
+#include <memory>
+#include <cmath>
+#include <winrt/Windows.Data.Json.h>
+#include <winrt/Windows.Data.Xml.Dom.h>
+#include <winrt/Windows.UI.Notifications.h>
+#include <winrt/Windows.Security.Cryptography.h>
+#include <winrt/Windows.Security.Cryptography.Core.h>
+#pragma comment(lib, "Ole32.lib")
+#pragma comment(lib, "Advapi32.lib")
+#pragma comment(lib, "Propsys.lib")
+namespace winrt::SparkNotifications {
+namespace React = Microsoft::ReactNative;
+namespace Json = Windows::Data::Json;
+namespace Toast = Windows::UI::Notifications;
+namespace Xml = Windows::Data::Xml::Dom;
+inline std::wstring Env(wchar_t const *key) {
+  auto size = GetEnvironmentVariableW(key, nullptr, 0); if (!size) return {};
+  std::wstring value(size, L'\0'); value.resize(GetEnvironmentVariableW(key, value.data(), size)); return value;
+}
+inline std::wstring Hash(hstring const &value) {
+  using namespace Windows::Security::Cryptography;
+  auto algorithm = Core::HashAlgorithmProvider::OpenAlgorithm(Core::HashAlgorithmNames::Sha256());
+  return std::wstring(CryptographicBuffer::EncodeToHexString(algorithm.HashData(CryptographicBuffer::ConvertStringToBinary(value, BinaryStringEncoding::Utf8))));
+}
+inline void Registry(std::wstring const &path, wchar_t const *name, std::wstring const &value) {
+  HKEY key{}; auto status = RegCreateKeyExW(HKEY_CURRENT_USER, path.c_str(), 0, nullptr, 0, KEY_SET_VALUE, nullptr, &key, nullptr);
+  check_win32(status); status = RegSetValueExW(key, name, 0, REG_SZ, reinterpret_cast<BYTE const *>(value.c_str()), static_cast<DWORD>((value.size() + 1) * sizeof(wchar_t))); RegCloseKey(key); check_win32(status);
+}
+struct NotificationsState : std::enable_shared_from_this<NotificationsState> {
+  React::ReactContext context;
+  std::wstring project, appId;
+  Toast::ToastNotifier notifier{nullptr};
+  struct Live { Toast::ToastNotification toast{nullptr}; event_token dismissed; };
+  std::map<std::wstring, Live> live;
+  static constexpr wchar_t const *group = L"Spark";
+  void Ensure() {
+    if (notifier) return;
+    project = Env(L"SPARK_PROJECT_ID"); if (project.empty()) throw hresult_invalid_argument(L"Missing project identity");
+    auto key = Hash(project); appId = L"Spark." + key;
+    auto classId = L"{" + key.substr(0, 8) + L"-" + key.substr(8, 4) + L"-" + key.substr(12, 4) + L"-" + key.substr(16, 4) + L"-" + key.substr(20, 12) + L"}";
+    wchar_t executable[32768]{}; if (!GetModuleFileNameW(nullptr, executable, 32768)) throw_last_error();
+    Json::JsonObject launch;
+    for (auto name : {L"SPARK_PROJECT_ID", L"SPARK_PROJECT_NAME", L"SPARK_PROJECT_VERSION", L"SPARK_WINDOW_CONFIG", L"SPARK_SESSION_FILE"}) launch.SetNamedValue(name, Json::JsonValue::CreateStringValue(Env(name)));
+    auto arguments = L"--spark-context=" + std::wstring(Windows::Foundation::Uri::EscapeComponent(launch.Stringify()));
+    Registry(L"Software\\Classes\\CLSID\\" + classId + L"\\LocalServer32", nullptr, L"\"" + std::wstring(executable) + L"\" " + arguments + L" --spark-toast-server");
+    Registry(L"Software\\Classes\\AppUserModelId\\" + appId, L"DisplayName", Env(L"SPARK_PROJECT_NAME"));
+    Registry(L"Software\\Classes\\AppUserModelId\\" + appId, L"CustomActivator", classId);
+    // Classic desktop toast activation requires a Start menu identity, scoped to this project.
+    auto link = create_instance<IShellLinkW>(CLSID_ShellLink); check_hresult(link->SetPath(executable)); check_hresult(link->SetArguments(arguments.c_str())); check_hresult(link->SetIconLocation(executable, 0));
+    auto properties = link.as<IPropertyStore>(); PROPVARIANT value{}; check_hresult(InitPropVariantFromString(appId.c_str(), &value));
+    auto result = properties->SetValue(PKEY_AppUserModel_ID, value); PropVariantClear(&value); check_hresult(result);
+    auto guid = winrt::guid(classId); check_hresult(InitPropVariantFromCLSID(guid, &value)); result = properties->SetValue(PKEY_AppUserModel_ToastActivatorCLSID, value); PropVariantClear(&value); check_hresult(result); check_hresult(properties->Commit());
+    PWSTR raw = nullptr; check_hresult(SHGetKnownFolderPath(FOLDERID_Programs, 0, nullptr, &raw)); std::filesystem::path folder(raw); CoTaskMemFree(raw);
+    check_hresult(link.as<IPersistFile>()->Save((folder / (L"Spark-" + key + L".lnk")).c_str(), TRUE));
+    auto candidate = Toast::ToastNotificationManager::CreateToastNotifier(appId);
+    // Like ToastNotificationManagerCompat.PreRegisterIdentityLessApp: an unpackaged
+    // identity must send once before Setting/GetScheduledToastNotifications work.
+    auto registration = L"Software\\Spark\\" + appId;
+    DWORD registered = 0, bytes = sizeof(registered);
+    if (RegGetValueW(HKEY_CURRENT_USER, registration.c_str(), L"ToastRegistered", RRF_RT_REG_DWORD, nullptr, &registered, &bytes) != ERROR_SUCCESS || !registered) {
+      Xml::XmlDocument xml; xml.LoadXml(L"<toast><visual><binding template='ToastGeneric'><text>Notifications enabled</text></binding></visual></toast>");
+      Toast::ToastNotification bootstrap(xml); bootstrap.SuppressPopup(true); bootstrap.Tag(L"bootstrap"); bootstrap.Group(L"SparkBootstrap"); bootstrap.ExpirationTime(clock::now() + std::chrono::seconds(15));
+      candidate.Show(bootstrap); Toast::ToastNotificationManager::History().Remove(L"bootstrap", L"SparkBootstrap", appId);
+      HKEY registry{}; check_win32(RegCreateKeyExW(HKEY_CURRENT_USER, registration.c_str(), 0, nullptr, 0, KEY_SET_VALUE, nullptr, &registry, nullptr)); registered = 1;
+      auto status = RegSetValueExW(registry, L"ToastRegistered", 0, REG_DWORD, reinterpret_cast<BYTE *>(&registered), sizeof(registered)); RegCloseKey(registry); check_win32(status);
+    }
+    notifier = candidate;
+  }
+  void Forget(std::wstring const &tag) { auto entry = live.find(tag); if (entry != live.end()) { entry->second.toast.Dismissed(entry->second.dismissed); live.erase(entry); } }
+  void Close() noexcept { for (auto &[tag, item] : live) try { item.toast.Dismissed(item.dismissed); } catch (...) {} live.clear(); }
+  void RemovePending(std::wstring const &tag) { for (auto const &item : notifier.GetScheduledToastNotifications()) if (item.Group() == group && (tag.empty() || item.Tag() == tag)) notifier.RemoveFromSchedule(item); }
+  static hstring Id(Xml::XmlDocument const &xml) { return Json::JsonObject::Parse(xml.DocumentElement().GetAttribute(L"launch")).GetNamedString(L"notificationId"); }
+  void Dismiss(hstring const &encoded) {
+    struct Search { HWND hwnd = nullptr; } found;
+    EnumWindows([](HWND hwnd, LPARAM state) -> BOOL { DWORD process; GetWindowThreadProcessId(hwnd, &process); if (process == GetCurrentProcessId() && GetPropW(hwnd, L"Spark.Window.main")) { reinterpret_cast<Search *>(state)->hwnd = hwnd; return FALSE; } return TRUE; }, reinterpret_cast<LPARAM>(&found));
+    if (found.hwnd) { COPYDATASTRUCT data{0x4C4E, static_cast<DWORD>((encoded.size() + 1) * sizeof(wchar_t)), const_cast<wchar_t *>(encoded.c_str())}; SendMessageW(found.hwnd, WM_COPYDATA, 0, reinterpret_cast<LPARAM>(&data)); }
+  }
+  void Show(Json::JsonObject const &args) {
+    if (notifier.Setting() != Toast::NotificationSetting::Enabled) throw hresult_access_denied(L"Notifications are disabled in Windows settings");
+    auto id = args.GetNamedString(L"id"), title = args.GetNamedString(L"title");
+    auto delay = args.GetNamedNumber(L"delay", 0);
+    if (id.empty() || title.empty() || !std::isfinite(delay) || delay < 0 || delay > 315360000) throw hresult_invalid_argument(L"Invalid notification or delay (maximum ten years)");
+    Json::JsonObject response; response.SetNamedValue(L"project", Json::JsonValue::CreateStringValue(project)); response.SetNamedValue(L"notificationId", Json::JsonValue::CreateStringValue(id)); response.SetNamedValue(L"data", args.GetNamedObject(L"data", Json::JsonObject())); response.SetNamedValue(L"action", Json::JsonValue::CreateStringValue(L"open"));
+    Xml::XmlDocument xml; xml.LoadXml(L"<toast><visual><binding template='ToastGeneric'/></visual></toast>"); xml.DocumentElement().SetAttribute(L"launch", response.Stringify());
+    auto binding = xml.SelectSingleNode(L"/toast/visual/binding");
+    for (auto field : {L"title", L"subtitle", L"body"}) { auto text = args.GetNamedString(field, L""); if (!text.empty()) { auto node = xml.CreateElement(L"text"); node.AppendChild(xml.CreateTextNode(text)); binding.AppendChild(node); } }
+    if (!args.GetNamedBoolean(L"sound", true)) { auto audio = xml.CreateElement(L"audio"); audio.SetAttribute(L"silent", L"true"); xml.DocumentElement().AppendChild(audio); }
+    auto tag = Hash(id); RemovePending(tag); Forget(tag);
+    if (delay > 0) {
+      Toast::ScheduledToastNotification toast(xml, clock::now() + std::chrono::milliseconds(static_cast<int64_t>(delay * 1000))); toast.Tag(tag); toast.Group(group); notifier.AddToSchedule(toast);
+    } else {
+      Toast::ToastNotification toast(xml); toast.Tag(tag); toast.Group(group);
+      response.SetNamedValue(L"action", Json::JsonValue::CreateStringValue(L"dismiss")); auto encoded = response.Stringify(); auto weak = weak_from_this(); auto dispatcher = context.UIDispatcher();
+      auto token = toast.Dismissed([weak, dispatcher, encoded](auto const &, Toast::ToastDismissedEventArgs const &event) { if (event.Reason() == Toast::ToastDismissalReason::UserCanceled) dispatcher.Post([weak, encoded]() { if (auto state = weak.lock()) state->Dismiss(encoded); }); });
+      try { notifier.Show(toast); live.emplace(tag, Live{toast, token}); } catch (...) { toast.Dismissed(token); throw; }
+    }
+  }
+};
+REACT_MODULE(SparkNotifications, L"NativeDesktopNotifications")
+struct SparkNotifications {
+  std::shared_ptr<NotificationsState> state = std::make_shared<NotificationsState>();
+  REACT_INIT(Initialize) void Initialize(React::ReactContext const &context) noexcept { state->context = context; }
+  ~SparkNotifications() { auto value = state; if (value->context) value->context.UIDispatcher().Post([value]() { value->Close(); }); }
+  REACT_METHOD(call) void call(std::string method, std::string encoded, React::ReactPromise<std::string> promise) noexcept {
+    auto value = state; value->context.UIDispatcher().Post([value, method, encoded, promise]() {
+      try {
+        value->Ensure(); auto args = Json::JsonObject::Parse(to_hstring(encoded));
+        if (method == "permission" || method == "requestPermission") { promise.Resolve(value->notifier.Setting() == Toast::NotificationSetting::Enabled ? "\"authorized\"" : "\"denied\""); return; }
+        if (method == "show") value->Show(args);
+        else if (method == "cancel") { auto tag = Hash(args.GetNamedString(L"id")); value->RemovePending(tag); value->Forget(tag); Toast::ToastNotificationManager::History().Remove(tag, value->group, value->appId); }
+        else if (method == "clear") { value->RemovePending(L""); value->Close(); Toast::ToastNotificationManager::History().RemoveGroup(value->group, value->appId); }
+        else if (method == "pending" || method == "delivered") {
+          Json::JsonArray result;
+          if (method == "pending") { for (auto const &item : value->notifier.GetScheduledToastNotifications()) if (item.Group() == value->group) result.Append(Json::JsonValue::CreateStringValue(value->Id(item.Content()))); }
+          else { for (auto const &item : Toast::ToastNotificationManager::History().GetHistory(value->appId)) if (item.Group() == value->group) result.Append(Json::JsonValue::CreateStringValue(value->Id(item.Content()))); }
+          promise.Resolve(to_string(result.Stringify())); return;
+        } else throw hresult_invalid_argument(L"Unsupported notification operation");
+        promise.Resolve("null");
+      } catch (hresult_error const &error) { promise.Reject(React::ReactError{error.code() == E_ACCESSDENIED ? "E_NOTIFICATION_PERMISSION" : "E_NOTIFICATION", to_string(error.message())}); }
+      catch (std::exception const &error) { promise.Reject(React::ReactError{"E_NOTIFICATION", error.what()}); }
+    });
+  }
+};
+}

package/vendor/node_modules/@legendapp/spark-notifications/windows/SparkNotifications/SparkNotifications.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>{3699BA52-65EE-4286-AC9B-BA28962A2A09}</ProjectGuid>
+    <ProjectName>SparkNotifications</ProjectName>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>SparkNotifications</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>SparkNotifications.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="SparkNotifications.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="SparkNotifications.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="SparkNotifications.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-notifications/windows/SparkNotifications/SparkNotifications.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="SparkNotifications.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="SparkNotifications.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="SparkNotifications.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>

package/vendor/node_modules/@legendapp/spark-notifications/windows/SparkNotifications/pch.cpp

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

package/vendor/node_modules/@legendapp/spark-notifications/windows/SparkNotifications/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-notifications/windows/SparkNotifications/resource.h

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

package/vendor/node_modules/@legendapp/spark-notifications/windows/SparkNotifications/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-notifications/windows/SparkNotifications.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}") = "SparkNotifications", "SparkNotifications\SparkNotifications.vcxproj", "{3699BA52-65EE-4286-AC9B-BA28962A2A09}"
+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
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Debug|x64.ActiveCfg = Debug|x64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Debug|x64.Build.0 = Debug|x64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Debug|x64.Deploy.0 = Debug|x64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Debug|x86.ActiveCfg = Debug|Win32
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Debug|x86.Build.0 = Debug|Win32
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Debug|x86.Deploy.0 = Debug|Win32
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Debug|ARM64.Build.0 = Debug|ARM64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Release|x64.ActiveCfg = Release|x64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Release|x64.Build.0 = Release|x64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Release|x64.Deploy.0 = Release|x64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Release|x86.ActiveCfg = Release|Win32
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Release|x86.Build.0 = Release|Win32
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Release|x86.Deploy.0 = Release|Win32
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Release|ARM64.ActiveCfg = Release|ARM64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Release|ARM64.Build.0 = Release|ARM64
+		{3699BA52-65EE-4286-AC9B-BA28962A2A09}.Release|ARM64.Deploy.0 = Release|ARM64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {7A5D2A23-0D39-439A-B406-48064E3B832C}
+	EndGlobalSection
+EndGlobal

package/vendor/node_modules/@legendapp/spark-processes/RNDesktopProcesses.podspec

@@ -0,0 +1,17 @@
+require "json"
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+Pod::Spec.new do |s|
+  s.name = "RNDesktopProcesses"
+  s.version = package["version"]
+  s.summary = "Desktop processes"
+  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"
+  s.frameworks = "AppKit"
+end

package/vendor/node_modules/@legendapp/spark-processes/macos/RNDesktopProcesses.h

@@ -0,0 +1,3 @@
+#import <RNDesktopProcessesSpec/RNDesktopProcessesSpec.h>
+@interface RNDesktopProcesses : NSObject <NativeDesktopProcessesSpec>
+@end

package/vendor/node_modules/@legendapp/spark-processes/macos/RNDesktopProcesses.mm

@@ -0,0 +1,153 @@
+#import "RNDesktopProcesses.h"
+#import <RNDesktopApp/SparkDesktop.h>
+#import <signal.h>
+#import <AppKit/AppKit.h>
+#import <spawn.h>
+#import <sys/wait.h>
+#import <vector>
+@interface SparkProcess : NSObject
+@property pid_t pid;
+@property BOOL running;
+@property NSFileHandle *input;
+@property BOOL timedOut;
+@property BOOL truncated;
+@property BOOL ended;
+@property dispatch_queue_t inputQueue;
+@end
+@implementation SparkProcess
+@end
+@interface RNDesktopProcesses ()
+@property NSMutableDictionary<NSString *, SparkProcess *> *processes;
+@property BOOL invalidated;
+@end
+@implementation RNDesktopProcesses
+RCT_EXPORT_MODULE(NativeDesktopProcesses)
++ (BOOL)requiresMainQueueSetup { return YES; }
+- (instancetype)init {
+  if (self = [super init]) {
+    _processes = [NSMutableDictionary new];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(stopAll) name:NSApplicationWillTerminateNotification object:nil];
+  }
+  return self;
+}
+- (void)stopAll { for (SparkProcess *process in self.processes.allValues) if (process.running) kill(-process.pid, SIGKILL); }
+- (void)dealloc { [[NSNotificationCenter defaultCenter] removeObserver:self]; }
+
+- (void)terminate:(SparkProcess *)process {
+  if (process.running) {
+    kill(-process.pid, SIGTERM);
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+      if (process.running) kill(-process.pid, SIGKILL);
+    });
+  }
+}
+
+- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSDictionary *args = SparkArgs(json); NSString *key = args[@"id"];
+    if (self.invalidated) { reject(@"E_CLOSED", @"Process module is closed", nil); return; }
+    SparkProcess *process = self.processes[key];
+    if ([method isEqual:@"spawn"]) {
+      if (process) { reject(@"E_EXISTS", @"Process id already exists", nil); return; }
+      NSString *executable = args[@"executable"];
+      if ([executable hasPrefix:@"helper:"]) {
+        NSString *name = [executable substringFromIndex:7];
+        if (!name.length || [name rangeOfCharacterFromSet:[[NSCharacterSet characterSetWithCharactersInString:@"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-"] invertedSet]].location != NSNotFound) { SparkInvalid(reject, @"Invalid helper name"); return; }
+        NSString *helpers = [NSBundle.mainBundle.bundlePath stringByAppendingPathComponent:@"Contents/Helpers"];
+        NSString *bundle = [helpers stringByAppendingPathComponent:[name stringByAppendingString:@".helper"]];
+        executable = [helpers stringByAppendingPathComponent:name];
+        if ([NSFileManager.defaultManager fileExistsAtPath:bundle]) {
+          NSString *entry = [NSString stringWithContentsOfFile:[bundle stringByAppendingPathComponent:@".spark-entry"] encoding:NSUTF8StringEncoding error:nil];
+          if (!entry.length || [entry hasPrefix:@"/"] || [entry containsString:@"\\"] || [[entry componentsSeparatedByString:@"/"] containsObject:@".."] || [entry containsString:@"\0"]) { SparkInvalid(reject, @"Invalid helper bundle entry"); return; }
+          executable = [bundle stringByAppendingPathComponent:entry];
+        }
+      }
+      if (![executable hasPrefix:@"/"]) { SparkInvalid(reject, @"Executable path must be absolute"); return; }
+      process = [SparkProcess new];
+      process.inputQueue = dispatch_queue_create("desktop.process.input", DISPATCH_QUEUE_SERIAL);
+      NSMutableDictionary *environment = [NSProcessInfo.processInfo.environment mutableCopy]; [environment addEntriesFromDictionary:args[@"env"] ?: @{}];
+      NSPipe *input = [NSPipe pipe], *output = [NSPipe pipe], *errorPipe = [NSPipe pipe];
+      process.input = input.fileHandleForWriting;
+      // Create the process group atomically, before executable code can fork.
+      // NSTask + setpgid after launch has a race and cannot provide this contract.
+      posix_spawnattr_t attributes; posix_spawnattr_init(&attributes);
+      posix_spawnattr_setflags(&attributes, POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_CLOEXEC_DEFAULT);
+      posix_spawnattr_setpgroup(&attributes, 0);
+      posix_spawn_file_actions_t actions; posix_spawn_file_actions_init(&actions);
+      posix_spawn_file_actions_adddup2(&actions, input.fileHandleForReading.fileDescriptor, STDIN_FILENO);
+      posix_spawn_file_actions_adddup2(&actions, output.fileHandleForWriting.fileDescriptor, STDOUT_FILENO);
+      posix_spawn_file_actions_adddup2(&actions, errorPipe.fileHandleForWriting.fileDescriptor, STDERR_FILENO);
+      if (args[@"cwd"]) posix_spawn_file_actions_addchdir_np(&actions, [args[@"cwd"] fileSystemRepresentation]);
+      NSArray *arguments = [@[executable] arrayByAddingObjectsFromArray:args[@"args"] ?: @[]];
+      NSMutableArray *variables = [NSMutableArray new];
+      for (NSString *name in environment) [variables addObject:[NSString stringWithFormat:@"%@=%@", name, environment[name]]];
+      std::vector<char *> argv, envp;
+      for (NSString *argument in arguments) argv.push_back((char *)argument.UTF8String); argv.push_back(nullptr);
+      for (NSString *variable in variables) envp.push_back((char *)variable.UTF8String); envp.push_back(nullptr);
+      pid_t pid = 0;
+      int error = posix_spawn(&pid, executable.fileSystemRepresentation, &actions, &attributes, argv.data(), envp.data());
+      posix_spawn_file_actions_destroy(&actions); posix_spawnattr_destroy(&attributes);
+      [input.fileHandleForReading closeFile]; [output.fileHandleForWriting closeFile]; [errorPipe.fileHandleForWriting closeFile];
+      if (error) { [process.input closeFile]; [output.fileHandleForReading closeFile]; [errorPipe.fileHandleForReading closeFile]; SparkReject(reject, [NSError errorWithDomain:NSPOSIXErrorDomain code:error userInfo:nil]); return; }
+      process.pid = pid; process.running = YES;
+      self.processes[key] = process;
+      NSMutableData *stdoutData = [NSMutableData new], *stderrData = [NSMutableData new];
+      dispatch_group_t group = dispatch_group_create();
+      NSArray *streams = @[output.fileHandleForReading, errorPipe.fileHandleForReading];
+      for (NSUInteger index = 0; index < streams.count; index++) {
+        NSFileHandle *handle = streams[index]; NSMutableData *buffer = index ? stderrData : stdoutData;
+        NSString *stream = index ? @"stderr" : @"stdout";
+        dispatch_group_async(group, dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+          @try {
+            while (YES) {
+              // readDataOfLength can wait for the requested length. A service's
+              // short readiness/response message must be delivered before EOF.
+              char bytes[16384]; ssize_t count;
+              do { count = read(handle.fileDescriptor, bytes, sizeof(bytes)); } while (count < 0 && errno == EINTR);
+              if (count <= 0) break;
+              NSData *data = [NSData dataWithBytes:bytes length:(NSUInteger)count];
+              @synchronized(process) { NSUInteger remaining = 8 * 1024 * 1024 - buffer.length; if (data.length > remaining) process.truncated = YES; [buffer appendData:[data subdataWithRange:NSMakeRange(0, MIN(remaining, data.length))]]; }
+              if ([args[@"streamOutput"] boolValue]) dispatch_sync(dispatch_get_main_queue(), ^{ if (!self.invalidated) SparkEmit(@{ @"type": @"processOutput", @"processId": key, @"stream": stream, @"base64": [data base64EncodedStringWithOptions:0] }); });
+            }
+          } @catch (NSException *exception) { /* Closing the runtime interrupts pipe reads. */ }
+          [handle closeFile];
+        });
+      }
+      dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+        int status = 0; while (waitpid(process.pid, &status, 0) < 0 && errno == EINTR) {}
+        dispatch_sync(dispatch_get_main_queue(), ^{
+          // Descendants must not keep the output pipes (and exited promise) alive.
+          kill(-process.pid, SIGKILL); process.running = NO;
+        });
+        dispatch_group_notify(group, dispatch_get_main_queue(), ^{
+          int terminationStatus = status;
+          process.ended = YES;
+          dispatch_async(process.inputQueue, ^{ @try { [process.input closeFile]; } @catch (NSException *exception) {} });
+          if (!self.invalidated) SparkEmit(@{ @"type": @"processExit", @"processId": key, @"result": @{
+            @"exitCode": @(WIFEXITED(terminationStatus) ? WEXITSTATUS(terminationStatus) : WTERMSIG(terminationStatus)), @"signal": @(WIFSIGNALED(terminationStatus)),
+            @"stdout": [[NSString alloc] initWithData:stdoutData encoding:NSUTF8StringEncoding] ?: @"", @"stderr": [[NSString alloc] initWithData:stderrData encoding:NSUTF8StringEncoding] ?: @"",
+            @"stdoutBase64": [stdoutData base64EncodedStringWithOptions:0], @"stderrBase64": [stderrData base64EncodedStringWithOptions:0],
+            @"timedOut": @(process.timedOut), @"outputTruncated": @(process.truncated) } });
+          [self.processes removeObjectForKey:key];
+        });
+      });
+      if (args[@"input"]) { NSData *data = [args[@"input"] dataUsingEncoding:NSUTF8StringEncoding]; dispatch_async(process.inputQueue, ^{ @try { [process.input writeData:data]; } @catch (NSException *exception) {} }); }
+      if (args[@"timeoutMs"]) dispatch_after(dispatch_time(DISPATCH_TIME_NOW, [args[@"timeoutMs"] doubleValue] * NSEC_PER_MSEC), dispatch_get_main_queue(), ^{
+        if (process.running) { process.timedOut = YES; [self terminate:process]; }
+      });
+    } else {
+      if (!process || process.ended) { if ([method isEqual:@"terminate"] || [method isEqual:@"closeInput"]) { resolve(@"null"); return; } reject(@"E_CLOSED", @"Process has exited", nil); return; }
+      if ([method isEqual:@"terminate"]) [self terminate:process];
+      else if ([method isEqual:@"write"] || [method isEqual:@"closeInput"]) {
+        dispatch_async(process.inputQueue, ^{
+          @try { if ([method isEqual:@"write"]) [process.input writeData:[args[@"text"] dataUsingEncoding:NSUTF8StringEncoding]]; else [process.input closeFile]; resolve(@"null"); }
+          @catch (NSException *exception) { reject(@"E_PIPE", @"Process input is closed", nil); }
+        }); return;
+      } else { SparkInvalid(reject, @"Unknown process operation"); return; }
+    }
+    resolve(@"null");
+  });
+}
+- (void)invalidate { dispatch_async(dispatch_get_main_queue(), ^{ self.invalidated = YES; [self stopAll]; }); }
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params { return std::make_shared<facebook::react::NativeDesktopProcessesSpecJSI>(params); }
+@end