@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-system/windows/SparkSystem/SparkSystem.h

@@ -0,0 +1,154 @@
+#pragma once
+#include "NativeModules.h"
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <filesystem>
+#include <powrprof.h>
+#include <wtsapi32.h>
+#include <shobjidl.h>
+#include <shlobj.h>
+#include <propkey.h>
+#include <propvarutil.h>
+#include <winrt/Windows.Data.Json.h>
+#include <winrt/Windows.UI.ViewManagement.h>
+#include <winrt/Windows.System.Profile.h>
+#include <winrt/Windows.Security.Cryptography.h>
+#include <winrt/Windows.Security.Cryptography.Core.h>
+#pragma comment(lib, "PowrProf.lib")
+#pragma comment(lib, "Wtsapi32.lib")
+#pragma comment(lib, "Shell32.lib")
+#pragma comment(lib, "Propsys.lib")
+#pragma comment(lib, "Gdi32.lib")
+namespace winrt::SparkSystem {
+namespace React = Microsoft::ReactNative;
+namespace Json = Windows::Data::Json;
+inline HWND MainWindow() {
+  struct Search { HWND result = nullptr; } search;
+  EnumWindows([](HWND hwnd, LPARAM value) -> BOOL { DWORD process; GetWindowThreadProcessId(hwnd, &process); if (process == GetCurrentProcessId() && GetPropW(hwnd, L"Spark.Window.main")) { reinterpret_cast<Search *>(value)->result = hwnd; return FALSE; } return TRUE; }, reinterpret_cast<LPARAM>(&search));
+  if (!search.result) throw hresult_error(E_FAIL, L"Main window is unavailable"); return search.result;
+}
+inline std::wstring Env(wchar_t const *name) { auto length = GetEnvironmentVariableW(name, nullptr, 0); if (!length) return {}; std::wstring value(length, L'\0'); value.resize(GetEnvironmentVariableW(name, value.data(), length)); return value; }
+inline std::wstring AppId() {
+  auto project = Env(L"SPARK_PROJECT_ID"); if (project.empty()) throw hresult_invalid_argument(L"Missing project identity");
+  using namespace Windows::Security::Cryptography;
+  auto hash = Core::HashAlgorithmProvider::OpenAlgorithm(Core::HashAlgorithmNames::Sha256());
+  return L"Spark." + std::wstring(CryptographicBuffer::EncodeToHexString(hash.HashData(CryptographicBuffer::ConvertStringToBinary(project, BinaryStringEncoding::Utf8))));
+}
+struct SystemState {
+  React::ReactContext context;
+  HWND hwnd = nullptr; bool observing = false;
+  uint64_t sequence = 0;
+  std::map<uint64_t, std::pair<handle, POWER_REQUEST_TYPE>> requests;
+  std::map<uint64_t, bool> attention;
+  std::wstring dockOwner;
+  bool badge = false;
+  void Emit(char const *type) { if (observing) context.EmitJSEvent(L"RCTDeviceEventEmitter", L"desktop", React::JSValueObject{{"type", type}}); }
+  static LRESULT CALLBACK Proc(HWND hwnd, UINT message, WPARAM w, LPARAM l) noexcept {
+    auto self = reinterpret_cast<SystemState *>(GetWindowLongPtrW(hwnd, GWLP_USERDATA));
+    if (self) try {
+      if (message == WM_POWERBROADCAST) {
+        if (w == PBT_APMSUSPEND) self->Emit("sleep");
+        else if (w == PBT_APMRESUMEAUTOMATIC) self->Emit("wake");
+        else if (w == PBT_APMPOWERSTATUSCHANGE) self->Emit("powerChanged");
+      } else if (message == WM_WTSSESSION_CHANGE) { if (w == WTS_SESSION_LOCK) self->Emit("lock"); else if (w == WTS_SESSION_UNLOCK) self->Emit("unlock"); }
+      else if (message == WM_SETTINGCHANGE || message == WM_THEMECHANGED) self->Emit("appearanceChanged");
+      else if (message == WM_DISPLAYCHANGE) self->Emit("displaysChanged");
+    } catch (...) {}
+    return DefWindowProcW(hwnd, message, w, l);
+  }
+  void EnsureWindow() {
+    if (hwnd) return;
+    WNDCLASSW cls{}; cls.lpfnWndProc = Proc; cls.lpszClassName = L"SparkSystem"; cls.hInstance = GetModuleHandleW(nullptr);
+    if (!RegisterClassW(&cls) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS) throw_last_error();
+    hwnd = CreateWindowExW(WS_EX_TOOLWINDOW, cls.lpszClassName, L"", WS_POPUP, 0, 0, 0, 0, nullptr, nullptr, cls.hInstance, nullptr);
+    if (!hwnd) throw_last_error(); SetWindowLongPtrW(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));
+    if (!WTSRegisterSessionNotification(hwnd, NOTIFY_FOR_THIS_SESSION)) { DestroyWindow(hwnd); hwnd = nullptr; throw_last_error(); }
+  }
+  static com_ptr<ITaskbarList3> Taskbar() { auto taskbar = create_instance<ITaskbarList3>(CLSID_TaskbarList); check_hresult(taskbar->HrInit()); return taskbar; }
+  static HICON Badge(std::wstring const &label) {
+    const int size = 32; BITMAPINFO info{}; info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); info.bmiHeader.biWidth = size; info.bmiHeader.biHeight = -size; info.bmiHeader.biPlanes = 1; info.bmiHeader.biBitCount = 32;
+    void *pixels = nullptr; auto color = CreateDIBSection(nullptr, &info, DIB_RGB_COLORS, &pixels, nullptr, 0); auto mask = CreateBitmap(size, size, 1, 1, nullptr); auto dc = CreateCompatibleDC(nullptr);
+    if (!color || !mask || !dc) { if (color) DeleteObject(color); if (mask) DeleteObject(mask); if (dc) DeleteDC(dc); throw_last_error(); }
+    auto old = SelectObject(dc, color); memset(pixels, 0, size * size * 4);
+    auto brush = CreateSolidBrush(RGB(190, 0, 30)); auto oldBrush = SelectObject(dc, brush); auto oldPen = SelectObject(dc, GetStockObject(NULL_PEN)); Ellipse(dc, 0, 0, size, size);
+    auto font = CreateFontW(-20, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, DEFAULT_CHARSET, 0, 0, ANTIALIASED_QUALITY, 0, L"Segoe UI"); auto oldFont = SelectObject(dc, font);
+    SetTextColor(dc, RGB(255, 255, 255)); SetBkMode(dc, TRANSPARENT); RECT rect{0, 0, size, size}; DrawTextW(dc, label.c_str(), static_cast<int>(label.size()), &rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_NOPREFIX);
+    auto bytes = static_cast<DWORD *>(pixels); for (int i = 0; i < size * size; ++i) if (bytes[i] & 0xffffff) bytes[i] |= 0xff000000;
+    SelectObject(dc, oldFont); SelectObject(dc, oldBrush); SelectObject(dc, oldPen); SelectObject(dc, old); DeleteObject(font); DeleteObject(brush); DeleteDC(dc);
+    ICONINFO icon{}; icon.fIcon = TRUE; icon.hbmColor = color; icon.hbmMask = mask; auto result = CreateIconIndirect(&icon); DeleteObject(color); DeleteObject(mask); if (!result) throw_last_error(); return result;
+  }
+  void ClearDock() { auto list = create_instance<ICustomDestinationList>(CLSID_DestinationList); check_hresult(list->SetAppID(AppId().c_str())); UINT slots; com_ptr<IObjectArray> removed; check_hresult(list->BeginList(&slots, IID_PPV_ARGS(removed.put()))); check_hresult(list->CommitList()); dockOwner.clear(); }
+  void DockMenu(Json::JsonObject const &args) {
+    auto list = create_instance<ICustomDestinationList>(CLSID_DestinationList); check_hresult(list->SetAppID(AppId().c_str()));
+    UINT slots; com_ptr<IObjectArray> removed; check_hresult(list->BeginList(&slots, IID_PPV_ARGS(removed.put())));
+    try {
+      auto tasks = create_instance<IObjectCollection>(CLSID_EnumerableObjectCollection);
+      wchar_t executable[32768]{}; GetModuleFileNameW(nullptr, executable, 32768);
+      auto owner = args.GetNamedString(L"owner");
+      for (auto const &value : args.GetNamedArray(L"items")) {
+        auto item = value.GetObject(); if (!item.GetNamedBoolean(L"enabled", true)) continue;
+        auto link = create_instance<IShellLinkW>(CLSID_ShellLink); check_hresult(link->SetPath(executable));
+        auto payload = std::wstring(Windows::Foundation::Uri::EscapeComponent(owner)) + L":" + std::wstring(Windows::Foundation::Uri::EscapeComponent(item.GetNamedString(L"id")));
+        Json::JsonObject launch;
+        for (auto key : {L"SPARK_PROJECT_ID", L"SPARK_PROJECT_NAME", L"SPARK_PROJECT_VERSION", L"SPARK_WINDOW_CONFIG", L"SPARK_SESSION_FILE"}) launch.SetNamedValue(key, Json::JsonValue::CreateStringValue(Env(key)));
+        auto command = L"--spark-context=" + std::wstring(Windows::Foundation::Uri::EscapeComponent(launch.Stringify())) + L" --spark-dock-action=" + std::wstring(payload); check_hresult(link->SetArguments(command.c_str()));
+        check_hresult(link->SetIconLocation(executable, 0));
+        auto title = (item.GetNamedBoolean(L"checked", false) ? std::wstring(L"\u2713 ") : std::wstring()) + std::wstring(item.GetNamedString(L"title"));
+        auto properties = link.as<IPropertyStore>(); PROPVARIANT titleValue{}; check_hresult(InitPropVariantFromString(title.c_str(), &titleValue));
+        auto result = properties->SetValue(PKEY_Title, titleValue); PropVariantClear(&titleValue); check_hresult(result); check_hresult(properties->Commit()); check_hresult(tasks->AddObject(link.get()));
+      }
+      auto array = tasks.as<IObjectArray>(); check_hresult(list->AddUserTasks(array.get())); check_hresult(list->CommitList()); dockOwner = std::wstring(owner);
+    } catch (...) { list->AbortList(); throw; }
+  }
+  void Close() noexcept {
+    for (auto &[id, request] : requests) { PowerClearRequest(request.first.get(), request.second); if (request.second == PowerRequestDisplayRequired) PowerClearRequest(request.first.get(), PowerRequestSystemRequired); } requests.clear();
+    try { FLASHWINFO flash{sizeof(FLASHWINFO), MainWindow(), FLASHW_STOP, 0, 0}; FlashWindowEx(&flash); if (badge) Taskbar()->SetOverlayIcon(MainWindow(), nullptr, L""); if (!dockOwner.empty()) ClearDock(); } catch (...) {}
+    if (hwnd) { WTSUnRegisterSessionNotification(hwnd); DestroyWindow(hwnd); hwnd = nullptr; }
+  }
+  static Json::JsonObject Info() {
+    Json::JsonObject result; auto version = std::stoull(std::wstring(Windows::System::Profile::AnalyticsInfo::VersionInfo().DeviceFamilyVersion()));
+    auto number = [&](wchar_t const *key, double value) { result.SetNamedValue(key, Json::JsonValue::CreateNumberValue(value)); };
+    result.SetNamedValue(L"osVersion", Json::JsonValue::CreateStringValue(std::to_wstring(version >> 48) + L"." + std::to_wstring((version >> 32) & 0xffff) + L"." + std::to_wstring((version >> 16) & 0xffff)));
+    SYSTEM_INFO info{}; GetNativeSystemInfo(&info); result.SetNamedValue(L"architecture", Json::JsonValue::CreateStringValue(info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM64 ? L"arm64" : info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ? L"x64" : L"x86"));
+    wchar_t locale[LOCALE_NAME_MAX_LENGTH]{}; GetUserDefaultLocaleName(locale, LOCALE_NAME_MAX_LENGTH); result.SetNamedValue(L"locale", Json::JsonValue::CreateStringValue(locale));
+    Windows::UI::ViewManagement::UISettings settings; auto color = settings.GetColorValue(Windows::UI::ViewManagement::UIColorType::Background); result.SetNamedValue(L"dark", Json::JsonValue::CreateBooleanValue(color.R + color.G + color.B < 384));
+    LASTINPUTINFO input{sizeof(LASTINPUTINFO)}; if (!GetLastInputInfo(&input)) throw_last_error(); number(L"idleSeconds", static_cast<DWORD>(GetTickCount() - input.dwTime) / 1000.0);
+    SYSTEM_POWER_STATUS power{}; if (!GetSystemPowerStatus(&power)) throw_last_error(); result.SetNamedValue(L"onBattery", Json::JsonValue::CreateBooleanValue(power.ACLineStatus == 0));
+    if (power.BatteryLifePercent <= 100 && !(power.BatteryFlag & 128)) number(L"batteryLevel", power.BatteryLifePercent / 100.0); else result.SetNamedValue(L"batteryLevel", Json::JsonValue::CreateNullValue());
+    return result;
+  }
+};
+REACT_MODULE(SparkSystem, L"NativeDesktopSystem")
+struct SparkSystem {
+  std::shared_ptr<SystemState> state = std::make_shared<SystemState>();
+  REACT_INIT(Initialize) void Initialize(React::ReactContext const &context) noexcept { state->context = context; }
+  ~SparkSystem() { auto current = state; if (current->context) current->context.UIDispatcher().Post([current]() { current->Close(); }); }
+  REACT_METHOD(call) void call(std::string method, std::string encoded, React::ReactPromise<std::string> promise) noexcept {
+    auto current = state;
+    current->context.UIDispatcher().Post([current, method, encoded, promise]() {
+      try {
+        auto args = Json::JsonObject::Parse(to_hstring(encoded));
+        if (method == "info") { promise.Resolve(to_string(SystemState::Info().Stringify())); return; }
+        if (method == "observe") { current->EnsureWindow(); current->observing = true; }
+        else if (method == "loginStatus") { promise.Resolve("\"unavailable\""); return; }
+        else if (method == "login") { promise.Reject(React::ReactError{"E_UNAVAILABLE", "Login startup requires a standalone distribution app"}); return; }
+        else if (method == "badge") { auto label = args.GetNamedString(L"label"); HICON icon = label.empty() ? nullptr : SystemState::Badge(std::wstring(label)); auto result = SystemState::Taskbar()->SetOverlayIcon(MainWindow(), icon, label.c_str()); if (icon) DestroyIcon(icon); check_hresult(result); current->badge = !label.empty(); }
+        else if (method == "attention") { auto id = ++current->sequence; bool critical = args.GetNamedBoolean(L"critical", false); current->attention[id] = critical; FLASHWINFO flash{sizeof(FLASHWINFO), MainWindow(), static_cast<DWORD>(FLASHW_TRAY | (critical ? FLASHW_TIMERNOFG : 0)), critical ? 0u : 3u, 0}; FlashWindowEx(&flash); promise.Resolve(std::to_string(id)); return; }
+        else if (method == "cancelAttention") { current->attention.erase(static_cast<uint64_t>(args.GetNamedNumber(L"id"))); if (current->attention.empty()) { FLASHWINFO flash{sizeof(FLASHWINFO), MainWindow(), FLASHW_STOP, 0, 0}; FlashWindowEx(&flash); } }
+        else if (method == "preventSleep") {
+          auto reason = args.GetNamedString(L"reason"); REASON_CONTEXT description{}; description.Version = POWER_REQUEST_CONTEXT_VERSION; description.Flags = POWER_REQUEST_CONTEXT_SIMPLE_STRING; description.Reason.SimpleReasonString = const_cast<wchar_t *>(reason.c_str());
+          handle request{PowerCreateRequest(&description)}; if (!request || request.get() == INVALID_HANDLE_VALUE) { request.detach(); throw_last_error(); } auto kind = args.GetNamedString(L"kind") == L"system" ? PowerRequestSystemRequired : PowerRequestDisplayRequired;
+          if (!PowerSetRequest(request.get(), kind)) throw_last_error(); if (kind == PowerRequestDisplayRequired && !PowerSetRequest(request.get(), PowerRequestSystemRequired)) throw_last_error();
+          auto id = ++current->sequence; current->requests.emplace(id, std::make_pair(std::move(request), kind)); promise.Resolve(std::to_string(id)); return;
+        } else if (method == "allowSleep") { auto found = current->requests.find(static_cast<uint64_t>(args.GetNamedNumber(L"id"))); if (found != current->requests.end()) { if (!PowerClearRequest(found->second.first.get(), found->second.second)) throw_last_error(); if (found->second.second == PowerRequestDisplayRequired) PowerClearRequest(found->second.first.get(), PowerRequestSystemRequired); current->requests.erase(found); } }
+        else if (method == "dockMenu") { if (!current->dockOwner.empty()) { promise.Reject(React::ReactError{"E_DOCK_MENU_EXISTS", "Remove the existing taskbar menu before replacing it"}); return; } current->DockMenu(args); }
+        else if (method == "clearDockMenu") { if (current->dockOwner == std::wstring(args.GetNamedString(L"owner"))) current->ClearDock(); }
+        else throw hresult_invalid_argument(L"Unknown system operation");
+        promise.Resolve("null");
+      } catch (hresult_error const &error) { promise.Reject(React::ReactError{"E_SYSTEM", to_string(error.message())}); }
+      catch (std::exception const &error) { promise.Reject(React::ReactError{"E_SYSTEM", error.what()}); }
+    });
+  }
+};
+}

package/vendor/node_modules/@legendapp/spark-system/windows/SparkSystem/SparkSystem.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>{6D9E4033-E86B-4133-8868-8B676E6A0C4A}</ProjectGuid>
+    <ProjectName>SparkSystem</ProjectName>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>SparkSystem</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>SparkSystem.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="SparkSystem.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="SparkSystem.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="SparkSystem.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-system/windows/SparkSystem/SparkSystem.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="SparkSystem.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="SparkSystem.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="SparkSystem.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>

package/vendor/node_modules/@legendapp/spark-system/windows/SparkSystem/pch.cpp

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

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

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

package/vendor/node_modules/@legendapp/spark-system/windows/SparkSystem/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-system/windows/SparkSystem.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}") = "SparkSystem", "SparkSystem\SparkSystem.vcxproj", "{6D9E4033-E86B-4133-8868-8B676E6A0C4A}"
+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
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Debug|x64.ActiveCfg = Debug|x64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Debug|x64.Build.0 = Debug|x64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Debug|x64.Deploy.0 = Debug|x64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Debug|x86.ActiveCfg = Debug|Win32
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Debug|x86.Build.0 = Debug|Win32
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Debug|x86.Deploy.0 = Debug|Win32
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Debug|ARM64.Build.0 = Debug|ARM64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Release|x64.ActiveCfg = Release|x64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Release|x64.Build.0 = Release|x64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Release|x64.Deploy.0 = Release|x64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Release|x86.ActiveCfg = Release|Win32
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Release|x86.Build.0 = Release|Win32
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Release|x86.Deploy.0 = Release|Win32
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Release|ARM64.ActiveCfg = Release|ARM64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Release|ARM64.Build.0 = Release|ARM64
+		{6D9E4033-E86B-4133-8868-8B676E6A0C4A}.Release|ARM64.Deploy.0 = Release|ARM64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {2F015DE0-54AB-4E9B-8010-975DB140D14E}
+	EndGlobalSection
+EndGlobal

package/vendor/node_modules/@legendapp/spark-tray/RNDesktopTray.podspec

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

@@ -0,0 +1,4 @@
+#import <RNDesktopTraySpec/RNDesktopTraySpec.h>
+#import <Foundation/Foundation.h>
+@interface RNDesktopTray : NSObject <NativeDesktopTraySpec>
+@end

package/vendor/node_modules/@legendapp/spark-tray/macos/RNDesktopTray.mm

@@ -0,0 +1,63 @@
+#import "RNDesktopTray.h"
+#import <RNDesktopApp/SparkDesktop.h>
+
+@interface SparkTrayItem : NSObject
+@property NSString *identifier;
+@property NSStatusItem *item;
+@property NSDictionary *options;
+- (void)clicked:(id)sender;
+- (void)selected:(NSMenuItem *)sender;
+@end
+@implementation SparkTrayItem
+- (void)clicked:(id)sender { SparkEmit(@{ @"type": @"trayClick", @"trayId": self.identifier }); }
+- (void)selected:(NSMenuItem *)sender { SparkEmit(@{ @"type": @"trayAction", @"trayId": self.identifier, @"itemId": sender.representedObject }); }
+@end
+static NSMenu *Menu(NSArray *items, SparkTrayItem *owner) {
+  NSMenu *menu = [NSMenu new]; menu.autoenablesItems = NO;
+  for (NSDictionary *entry in items) {
+    if ([entry[@"separator"] boolValue]) { [menu addItem:NSMenuItem.separatorItem]; continue; }
+    NSMenuItem *item = [[NSMenuItem alloc] initWithTitle:entry[@"title"] action:@selector(selected:) keyEquivalent:@""];
+    item.target = owner; item.representedObject = entry[@"id"];
+    item.enabled = !entry[@"enabled"] || [entry[@"enabled"] boolValue]; item.state = [entry[@"checked"] boolValue] ? NSControlStateValueOn : NSControlStateValueOff;
+    if (entry[@"items"]) item.submenu = Menu(entry[@"items"], owner);
+    [menu addItem:item];
+  }
+  return menu;
+}
+@interface RNDesktopTray ()
+@property NSMutableDictionary<NSString *, SparkTrayItem *> *items;
+@end
+@implementation RNDesktopTray
+RCT_EXPORT_MODULE(NativeDesktopTray)
++ (BOOL)requiresMainQueueSetup { return YES; }
+- (instancetype)init { if (self = [super init]) _items = [NSMutableDictionary new]; return self; }
+- (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 (![key isKindOfClass:NSString.class] || !key.length) { SparkInvalid(reject, @"Tray needs an id"); return; }
+    SparkTrayItem *owner = self.items[key];
+    if ([method isEqual:@"remove"]) { if (owner) [NSStatusBar.systemStatusBar removeStatusItem:owner.item]; [self.items removeObjectForKey:key]; resolve(@"null"); return; }
+    if (![method isEqual:@"create"] && ![method isEqual:@"update"]) { SparkInvalid(reject, @"Unknown tray operation"); return; }
+    if ([method isEqual:@"create"] && owner) { reject(@"E_TRAY_EXISTS", @"Tray id already exists", nil); return; }
+    if ([method isEqual:@"update"] && !owner) { reject(@"E_NOT_FOUND", @"Tray was removed", nil); return; }
+    NSMutableDictionary *options = [owner.options mutableCopy] ?: [NSMutableDictionary new]; [options addEntriesFromDictionary:args];
+    NSImage *image = nil;
+    if ([options[@"symbol"] length]) {
+      image = [NSImage imageWithSystemSymbolName:options[@"symbol"] accessibilityDescription:options[@"tooltip"] ?: options[@"title"]];
+      if (!image) { SparkInvalid(reject, @"Unknown SF Symbol name"); return; }
+      [image setTemplate:YES];
+    }
+    if (![options[@"title"] length] && !image) { SparkInvalid(reject, @"Tray needs a title or symbol"); return; }
+    if (!owner) { owner = [SparkTrayItem new]; owner.identifier = key; owner.item = [NSStatusBar.systemStatusBar statusItemWithLength:NSVariableStatusItemLength]; self.items[key] = owner; }
+    owner.options = options;
+    owner.item.button.title = options[@"title"] ?: @""; owner.item.button.image = image;
+    owner.item.button.imagePosition = NSImageLeft; owner.item.button.toolTip = options[@"tooltip"];
+    owner.item.button.target = owner; owner.item.button.action = @selector(clicked:);
+    owner.item.button.accessibilityIdentifier = [@"spark.tray." stringByAppendingString:key];
+    owner.item.menu = [options[@"menu"] count] ? Menu(options[@"menu"], owner) : nil;
+    resolve(@"null");
+  });
+}
+- (void)invalidate { dispatch_async(dispatch_get_main_queue(), ^{ for (SparkTrayItem *owner in self.items.allValues) [NSStatusBar.systemStatusBar removeStatusItem:owner.item]; [self.items removeAllObjects]; }); }
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params { return std::make_shared<facebook::react::NativeDesktopTraySpecJSI>(params); }
+@end

package/vendor/node_modules/@legendapp/spark-tray/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@legendapp/spark-tray",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "main": "src/index.ts",
+  "react-native": "src/index.ts",
+  "files": [
+    "src",
+    "macos",
+    "*.podspec",
+    "windows",
+    "react-native.config.js"
+  ],
+  "peerDependencies": {
+    "react": "19.1.4",
+    "react-native": "0.81.6"
+  },
+  "codegenConfig": {
+    "name": "RNDesktopTraySpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "ios": {
+      "modulesProvider": {
+        "NativeDesktopTray": "RNDesktopTray"
+      }
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "nativeModules": [
+      "NativeDesktopTray"
+    ],
+    "pod": "RNDesktopTray",
+    "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-tray/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-tray/src/NativeDesktopTray.ts

@@ -0,0 +1,4 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+export interface Spec extends TurboModule { call(method: string, args: string): Promise<string>; }
+export default TurboModuleRegistry.getEnforcing<Spec>("NativeDesktopTray");

package/vendor/node_modules/@legendapp/spark-tray/src/index.ts

@@ -0,0 +1,46 @@
+import Native from "./NativeDesktopTray";
+import { onDesktopEvent } from "@legendapp/spark-desktop-app";
+
+export type TrayMenuItem = { id: string; title: string; enabled?: boolean; checked?: boolean; items?: TrayMenuItem[] } | { separator: true };
+export type TrayOptions = { id: string; title?: string; /** SF Symbol name. */ symbol?: string; tooltip?: string; menu?: TrayMenuItem[] };
+export type TrayAction = { trayId: string; itemId?: string; type: "trayClick" | "trayAction" };
+async function call<T = void>(method: string, args: object): Promise<T> { return JSON.parse(await Native.call(method, JSON.stringify(args))) as T; }
+function validate(options: Partial<TrayOptions>) {
+  if (options.id !== undefined && !/^[a-zA-Z0-9_-]{1,100}$/.test(options.id)) throw new Error("Invalid tray id");
+  if (options.title !== undefined && typeof options.title !== "string") throw new Error("Tray title must be a string");
+  const ids = new Set<string>();
+  function menu(items: TrayMenuItem[], depth: number) {
+    if (depth > 5) throw new Error("Tray menus support at most five levels");
+    for (const item of items) {
+      if ("separator" in item) continue;
+      if (!item.id || ids.has(item.id) || !item.title) throw new Error("Tray menu items need unique ids and titles");
+      ids.add(item.id);
+      if (item.items) menu(item.items, depth + 1);
+    }
+  }
+  if (options.menu) menu(options.menu, 1);
+}
+export async function createTray(options: TrayOptions, onAction: (action: TrayAction) => void = () => {}) {
+  validate(options);
+  if (!options.id || (!options.title && !options.symbol)) throw new Error("Tray needs an id and a title or symbol");
+  let removed = false;
+  let queue: Promise<unknown> = Promise.resolve();
+  const sub = onDesktopEvent(event => {
+    if (!removed && event.trayId === options.id && (event.type === "trayClick" || event.type === "trayAction")) onAction(event as TrayAction);
+  });
+  try { await call("create", options); } catch (error) { sub.remove(); throw error; }
+  return {
+    async update(changes: Omit<Partial<TrayOptions>, "id">) {
+      if (removed) throw new Error("Tray was removed");
+      validate(changes);
+      const next = queue.then(() => call("update", { ...changes, id: options.id }));
+      queue = next.catch(() => {});
+      await next;
+    },
+    async remove() {
+      if (removed) return;
+      removed = true; sub.remove();
+      await queue; await call("remove", { id: options.id });
+    },
+  };
+}