@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-audio/windows/SparkAudio/SparkAudio.h

@@ -0,0 +1,146 @@
+#pragma once
+#include "NativeModules.h"
+#include <winrt/Windows.Media.h>
+#include <winrt/Windows.Media.Core.h>
+#include <winrt/Windows.Media.Playback.h>
+#include <winrt/Windows.Storage.h>
+#include <winrt/Windows.Data.Json.h>
+#include <map>
+#include <memory>
+#include <cmath>
+#include <atomic>
+#include <mutex>
+#include <set>
+#include <winrt/Windows.Storage.Streams.h>
+namespace winrt::SparkAudio {
+namespace React = Microsoft::ReactNative;
+namespace Json = Windows::Data::Json;
+struct Entry { Windows::Media::Playback::MediaPlayer player{nullptr}; std::atomic<bool> ended{false}; std::atomic<bool> failed{false}; std::atomic<bool> loaded{false}; };
+struct MediaSession {
+  Windows::Media::Playback::MediaPlayer player{nullptr};
+  std::mutex mutex;
+  std::set<std::wstring> allowed;
+  Json::JsonArray commands;
+  Json::JsonObject state;
+  ~MediaSession() { if (player) { player.SystemMediaTransportControls().IsEnabled(false); player.Close(); } }
+  void Command(hstring const &name, double position = -1) {
+    std::lock_guard lock(mutex); if (!allowed.count(std::wstring(name)) || commands.Size() >= 128) return;
+    Json::JsonObject value; value.SetNamedValue(L"command", Json::JsonValue::CreateStringValue(name));
+    if (position >= 0) value.SetNamedValue(L"position", Json::JsonValue::CreateNumberValue(position));
+    commands.Append(value);
+  }
+};
+inline void Metadata(Windows::Media::SystemMediaTransportControls const &controls, Json::JsonObject const &metadata) {
+  auto display = controls.DisplayUpdater(); display.ClearAll(); display.Type(Windows::Media::MediaPlaybackType::Music);
+  display.MusicProperties().Title(metadata.GetNamedString(L"title", L""));
+  display.MusicProperties().Artist(metadata.GetNamedString(L"artist", L""));
+  display.MusicProperties().AlbumTitle(metadata.GetNamedString(L"albumTitle", L""));
+  auto artwork = metadata.GetNamedString(L"artworkUrl", L"");
+  if (!artwork.empty()) display.Thumbnail(Windows::Storage::Streams::RandomAccessStreamReference::CreateFromUri(Windows::Foundation::Uri(artwork)));
+  display.Update();
+}
+inline void UpdateSession(std::shared_ptr<MediaSession> const &session, Json::JsonObject const &patch) {
+  for (auto const &pair : patch) session->state.SetNamedValue(pair.Key(), pair.Value());
+  auto state = session->state; auto controls = session->player.SystemMediaTransportControls();
+  if (patch.HasKey(L"metadata")) Metadata(controls, patch.GetNamedObject(L"metadata"));
+  auto status = state.GetNamedString(L"playbackState", L"stopped");
+  controls.PlaybackStatus(status == L"playing" ? Windows::Media::MediaPlaybackStatus::Playing : status == L"paused" ? Windows::Media::MediaPlaybackStatus::Paused : Windows::Media::MediaPlaybackStatus::Stopped);
+  auto duration = state.GetNamedNumber(L"duration", 0), position = state.GetNamedNumber(L"position", 0);
+  Windows::Media::SystemMediaTransportControlsTimelineProperties timeline;
+  auto span = [](double seconds) { return std::chrono::duration_cast<Windows::Foundation::TimeSpan>(std::chrono::duration<double>(seconds)); };
+  timeline.StartTime(span(0)); timeline.MinSeekTime(span(0)); timeline.EndTime(span(duration)); timeline.MaxSeekTime(span(duration)); timeline.Position(span(std::min(position, duration)));
+  controls.UpdateTimelineProperties(timeline);
+  std::lock_guard lock(session->mutex);
+  session->allowed.clear();
+  if (state.HasKey(L"commands")) for (auto const &command : state.GetNamedArray(L"commands")) session->allowed.insert(std::wstring(command.GetString()));
+  else session->allowed = {L"play", L"pause"};
+  controls.IsPlayEnabled(session->allowed.count(L"play") != 0); controls.IsPauseEnabled(session->allowed.count(L"pause") != 0);
+  controls.IsNextEnabled(session->allowed.count(L"nextTrack") != 0); controls.IsPreviousEnabled(session->allowed.count(L"previousTrack") != 0);
+  controls.IsEnabled(true);
+}
+struct Players {
+  std::map<std::string, std::shared_ptr<Entry>> values;
+  std::string sessionID;
+  std::shared_ptr<MediaSession> session;
+  ~Players() { session.reset(); for (auto const &[id, entry] : values) { entry->player.Pause(); entry->player.Close(); } }
+};
+REACT_MODULE(SparkAudio, L"NativeSparkAudio")
+struct SparkAudio {
+  React::ReactContext context;
+  std::shared_ptr<Players> players = std::make_shared<Players>();
+  REACT_INIT(Initialize)
+  void Initialize(React::ReactContext const &value) noexcept { context = value; }
+  static fire_and_forget Invoke(std::shared_ptr<Players> players, std::string method, std::string encoded, React::ReactPromise<std::string> promise) {
+    try {
+      auto args = Json::JsonObject::Parse(to_hstring(encoded)); auto id = to_string(args.GetNamedString(L"id"));
+      if (method.starts_with("session")) {
+        if (method == "sessionCreate") {
+          players->session.reset();
+          for (auto const &[key, entry] : players->values) entry->player.SystemMediaTransportControls().IsEnabled(false);
+          auto session = std::make_shared<MediaSession>(); session->player = Windows::Media::Playback::MediaPlayer();
+          session->player.CommandManager().IsEnabled(false);
+          std::weak_ptr<MediaSession> weak = session; auto controls = session->player.SystemMediaTransportControls();
+          controls.ButtonPressed([weak](auto const &, auto const &event) { if (auto current = weak.lock()) {
+            using Button = Windows::Media::SystemMediaTransportControlsButton;
+            auto button = event.Button();
+            auto name = button == Button::Play ? L"play" : button == Button::Pause ? L"pause" : button == Button::Next ? L"nextTrack" : button == Button::Previous ? L"previousTrack" : L"";
+            if (*name) current->Command(name);
+          } });
+          controls.PlaybackPositionChangeRequested([weak](auto const &, auto const &event) { if (auto current = weak.lock()) current->Command(L"seekTo", std::chrono::duration<double>(event.RequestedPlaybackPosition()).count()); });
+          players->session = session; players->sessionID = id;
+          UpdateSession(session, args);
+        } else {
+          if (!players->session || players->sessionID != id) throw hresult_invalid_argument(L"Media session has been replaced");
+          if (method == "sessionUpdate") UpdateSession(players->session, args);
+          else if (method == "sessionRemove") { players->session.reset(); players->sessionID.clear(); }
+          else if (method == "sessionCommands") {
+            std::lock_guard lock(players->session->mutex);
+            auto result = to_string(players->session->commands.Stringify()); players->session->commands.Clear(); promise.Resolve(result); co_return;
+          } else throw hresult_invalid_argument(L"Unknown media session operation");
+        }
+      } else if (method == "create") {
+        auto uri = args.GetNamedString(L"uri"); Windows::Media::Core::MediaSource source{nullptr};
+        if ((uri.size() > 2 && uri[1] == L':') || std::wstring(uri).starts_with(L"\\\\")) {
+          auto file = co_await Windows::Storage::StorageFile::GetFileFromPathAsync(uri);
+          source = Windows::Media::Core::MediaSource::CreateFromStorageFile(file);
+        } else source = Windows::Media::Core::MediaSource::CreateFromUri(Windows::Foundation::Uri(uri));
+        Windows::Media::Playback::MediaPlayer player; player.AutoPlay(false);
+        auto controls = player.SystemMediaTransportControls(); controls.IsEnabled(!players->session); controls.IsPlayEnabled(true); controls.IsPauseEnabled(true);
+        auto display = controls.DisplayUpdater(); display.Type(Windows::Media::MediaPlaybackType::Music); display.MusicProperties().Title(args.GetNamedString(L"title", L"Music")); display.Update();
+        auto entry = std::make_shared<Entry>(); entry->player = player; std::weak_ptr<Entry> weak = entry;
+        player.MediaEnded([weak](auto const &, auto const &) { if (auto entry = weak.lock()) entry->ended = true; });
+        player.MediaFailed([weak](auto const &, auto const &) { if (auto entry = weak.lock()) entry->failed = true; });
+        player.MediaOpened([weak](auto const &, auto const &) { if (auto entry = weak.lock()) entry->loaded = true; });
+        player.Source(source);
+        players->values.emplace(id, entry);
+      } else {
+        auto found = players->values.find(id);
+        if (found == players->values.end()) throw hresult_invalid_argument(L"Audio player is not available");
+        auto entry = found->second; auto player = entry->player; auto session = player.PlaybackSession();
+        if (method == "ready") { if (entry->failed) throw hresult_error(E_FAIL, L"Audio could not be decoded or loaded"); promise.Resolve(entry->loaded ? "true" : "false"); co_return; }
+        else if (method == "volume") { auto volume = args.GetNamedNumber(L"volume"); if (!std::isfinite(volume) || volume < 0 || volume > 1) throw hresult_invalid_argument(L"Invalid volume"); player.Volume(volume); }
+        else if (method == "metadata") Metadata(player.SystemMediaTransportControls(), args.GetNamedObject(L"metadata"));
+        else if (method == "play") { if (!players->session) player.SystemMediaTransportControls().IsEnabled(true); entry->ended = false; player.Play(); }
+        else if (method == "pause") player.Pause();
+        else if (method == "seek") { entry->ended = false; auto seconds = args.GetNamedNumber(L"seconds"); if (!std::isfinite(seconds) || seconds < 0) throw hresult_invalid_argument(L"Invalid seek position"); session.Position(std::chrono::duration_cast<Windows::Foundation::TimeSpan>(std::chrono::duration<double>(seconds))); }
+        else if (method == "remove") { player.Pause(); player.Close(); players->values.erase(found); }
+        else if (method == "status") {
+          auto position = std::chrono::duration<double>(session.Position()).count(), duration = std::chrono::duration<double>(session.NaturalDuration()).count();
+          Json::JsonObject status;
+          status.SetNamedValue(L"volume", Json::JsonValue::CreateNumberValue(player.Volume()));
+          status.SetNamedValue(L"playing", Json::JsonValue::CreateBooleanValue(session.PlaybackState() == Windows::Media::Playback::MediaPlaybackState::Playing));
+          status.SetNamedValue(L"currentTime", Json::JsonValue::CreateNumberValue(position)); status.SetNamedValue(L"duration", Json::JsonValue::CreateNumberValue(duration));
+          status.SetNamedValue(L"didJustFinish", Json::JsonValue::CreateBooleanValue(entry->ended.load())); status.SetNamedValue(L"error", entry->failed ? Json::JsonValue::CreateStringValue(L"Audio could not be decoded or loaded") : Json::JsonValue::CreateNullValue());
+          promise.Resolve(to_string(status.Stringify())); co_return;
+        } else throw hresult_invalid_argument(L"Unknown audio operation");
+      }
+      promise.Resolve("null");
+    } catch (hresult_error const &error) { promise.Reject(React::ReactError{"E_AUDIO", to_string(error.message())}); }
+    catch (std::exception const &error) { promise.Reject(error.what()); }
+  }
+  REACT_METHOD(call)
+  void call(std::string method, std::string args, React::ReactPromise<std::string> promise) noexcept {
+    context.UIDispatcher().Post([players = players, method, args, promise]() { Invoke(players, method, args, promise); });
+  }
+};
+}

package/vendor/node_modules/@legendapp/spark-audio/windows/SparkAudio/SparkAudio.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>{155E56BB-0329-4862-A038-DD145A07BDC9}</ProjectGuid>
+    <ProjectName>SparkAudio</ProjectName>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>SparkAudio</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>SparkAudio.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="SparkAudio.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="SparkAudio.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="SparkAudio.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-audio/windows/SparkAudio/SparkAudio.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>{FF023A5B-B86A-446E-BE58-A4C2F8D185D2}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{494224E0-A01F-4AEE-83C9-7D83DE089225}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{74BB1314-F0AD-4FC9-B863-D02752E233A4}</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="SparkAudio.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="SparkAudio.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="SparkAudio.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>

package/vendor/node_modules/@legendapp/spark-audio/windows/SparkAudio/pch.cpp

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

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

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

package/vendor/node_modules/@legendapp/spark-audio/windows/SparkAudio/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-audio/windows/SparkAudio.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("{3F9056F1-9C79-455B-976C-740F30C60B22}") = "SparkAudio", "SparkAudio\SparkAudio.vcxproj", "{155E56BB-0329-4862-A038-DD145A07BDC9}"
+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
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Debug|x64.ActiveCfg = Debug|x64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Debug|x64.Build.0 = Debug|x64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Debug|x64.Deploy.0 = Debug|x64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Debug|x86.ActiveCfg = Debug|Win32
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Debug|x86.Build.0 = Debug|Win32
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Debug|x86.Deploy.0 = Debug|Win32
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Debug|ARM64.Build.0 = Debug|ARM64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Release|x64.ActiveCfg = Release|x64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Release|x64.Build.0 = Release|x64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Release|x64.Deploy.0 = Release|x64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Release|x86.ActiveCfg = Release|Win32
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Release|x86.Build.0 = Release|Win32
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Release|x86.Deploy.0 = Release|Win32
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Release|ARM64.ActiveCfg = Release|ARM64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Release|ARM64.Build.0 = Release|ARM64
+		{155E56BB-0329-4862-A038-DD145A07BDC9}.Release|ARM64.Deploy.0 = Release|ARM64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {453279D0-B201-4C21-BDE6-399EF6154BCA}
+	EndGlobalSection
+EndGlobal

package/vendor/node_modules/@legendapp/spark-auth-session/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@legendapp/spark-auth-session",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "main": "src/index",
+  "react-native": "src/index",
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "@legendapp/spark-desktop-links": "0.0.1-next.2",
+    "base64-js": "1.5.1"
+  },
+  "peerDependencies": {
+    "react-native": "0.81.6",
+    "expo-web-browser": "~15.0.10",
+    "expo-crypto": "~15.0.8"
+  },
+  "peerDependenciesMeta": {
+    "expo-web-browser": {
+      "optional": true
+    },
+    "expo-crypto": {
+      "optional": true
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "platforms": [
+      "macos",
+      "windows",
+      "ios",
+      "android",
+      "web"
+    ],
+    "requires": [
+      "@legendapp/spark-desktop-links"
+    ]
+  },
+  "private": true
+}

package/vendor/node_modules/@legendapp/spark-auth-session/src/core.ts

@@ -0,0 +1,68 @@
+import { authorize, callbackMatches, timeout, validateRedirect, type AuthSession, type AuthSessionOptions, type AuthSessionResult } from "./types";
+export type AuthTransport = {
+  randomState(): Promise<string>;
+  prepare(id: string, port: number, path: string): Promise<string>;
+  poll(id: string): Promise<string[]>;
+  close(id: string): Promise<void>;
+  subscribe(listener: (url: string) => void): Promise<{ remove(): void }>;
+  open(url: string): Promise<unknown>;
+};
+export function authSessions(transport: AuthTransport) {
+  let busy = false, sequence = 0;
+  return async function createAuthSession(options: AuthSessionOptions = {}): Promise<AuthSession> {
+    const duration = timeout(options);
+    if (busy) throw Object.assign(new Error("An authentication session is already active"), { code: "E_BUSY" });
+    if (options.signal?.aborted) throw Object.assign(new Error("Authentication was cancelled"), { name: "AbortError" });
+    busy = true;
+    const id = `auth-${Date.now()}-${++sequence}`;
+    let loopback = false, closed = false, opened = false, subscription: { remove(): void } | undefined;
+    let timer: ReturnType<typeof setTimeout> | undefined, polling: ReturnType<typeof setTimeout> | undefined;
+    let resolve!: (result: AuthSessionResult) => void;
+    const result = new Promise<AuthSessionResult>(done => { resolve = done; });
+    let closing: Promise<void> | undefined, failure: unknown;
+    const cleanup = () => closing ??= (async () => {
+      closed = true; clearTimeout(timer); clearTimeout(polling); subscription?.remove(); options.signal?.removeEventListener("abort", cancel);
+      try { if (loopback) await transport.close(id); } finally { busy = false; }
+    })();
+    const finish = async (value: AuthSessionResult) => { if (closed) return; try { await cleanup(); } catch (error) { failure = error; } finally { resolve(value); } };
+    const cancel = () => { void finish({ type: "cancel" }).catch(console.error); };
+    try {
+      const state = await transport.randomState();
+      let redirectUri = options.redirectUri;
+      if (!redirectUri) { loopback = true; redirectUri = await transport.prepare(id, 0, "/auth/callback"); }
+      else {
+        const uri = validateRedirect(redirectUri);
+        if (uri.protocol === "http:") {
+          if (uri.hostname !== "127.0.0.1" || !uri.port || !/^\/[a-zA-Z0-9/_-]*$/.test(uri.pathname)) throw new TypeError("Desktop HTTP callbacks require 127.0.0.1, an explicit port, and a plain path");
+          loopback = true; redirectUri = await transport.prepare(id, Number(uri.port), uri.pathname);
+        } else if (uri.protocol === "https:") throw new TypeError("Desktop callbacks require a loopback URI or registered application scheme");
+      }
+      const redirect = redirectUri;
+      const received = (url: string) => { if (opened && !closed && callbackMatches(url, redirect, state)) void finish({ type: "success", url }).catch(console.error); };
+      if (!loopback) subscription = await transport.subscribe(received);
+      async function poll() {
+        try { for (const url of await transport.poll(id)) received(url); }
+        catch (error) { if (!closed) { failure = error; await finish({ type: "dismiss" }); } }
+        finally { if (!closed) polling = setTimeout(poll, 100); }
+      }
+      options.signal?.addEventListener("abort", cancel, { once: true });
+      timer = setTimeout(() => { void finish({ type: "timeout" }).catch(console.error); }, duration);
+      if (options.signal?.aborted) cancel();
+      return {
+        state, redirectUri: redirect,
+        async open(url) {
+          if (opened) throw new Error("Auth sessions can only be opened once");
+          if (closed) { const value = await result; if (failure) throw failure; return value; }
+          try {
+            authorize(url, state, redirect); opened = true;
+            if (loopback) void poll();
+            // Don't let a slow browser launch suppress cancellation or a received callback.
+            const launch = transport.open(url).then(() => result);
+            const value = await Promise.race([result, launch]); if (failure) throw failure; return value;
+          } catch (error) { try { await cleanup(); } finally { resolve({ type: "dismiss" }); } throw error; }
+        },
+        async dismiss() { await finish({ type: "dismiss" }); if (failure) throw failure; },
+      };
+    } catch (error) { try { await cleanup(); } finally { resolve({ type: "dismiss" }); } throw error; }
+  };
+}

package/vendor/node_modules/@legendapp/spark-auth-session/src/index.android.ts

@@ -0,0 +1 @@
+export * from "./mobile";

package/vendor/node_modules/@legendapp/spark-auth-session/src/index.ios.ts

@@ -0,0 +1 @@
+export * from "./mobile";

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

@@ -0,0 +1,22 @@
+import Native from "@legendapp/spark-desktop-links/src/NativeDesktopLinks";
+import { onOpen, openURL } from "@legendapp/spark-desktop-links";
+import { authSessions } from "./core";
+import { validateCount, validateDigest } from "./types";
+export type * from "./types";
+async function call<T>(method: string, args: object): Promise<T> { return JSON.parse(await Native.call(method, JSON.stringify(args))); }
+export async function getRandomBytesAsync(count: number): Promise<Uint8Array> {
+  validateCount(count); const base64 = await call<string>("cryptoRandom", { count });
+  const { toByteArray } = await import("base64-js"); return toByteArray(base64);
+}
+export async function digestStringAsync(algorithm: "SHA-256", value: string): Promise<string> {
+  validateDigest(algorithm, value); return call("cryptoDigest", { value });
+}
+export const createAuthSession = authSessions({
+  randomState: async () => Array.from(await getRandomBytesAsync(32), byte => byte.toString(16).padStart(2, "0")).join(""),
+  prepare: (id, port, path) => call("authPrepare", { id, port, path }),
+  poll: id => call("authPoll", { id }), close: id => call("authClose", { id }),
+  subscribe: listener => onOpen(event => { if (event.type === "openURL") listener(event.url); }),
+  open: openURL,
+});
+/** Desktop receives callbacks natively; no popup-completion step is needed. */
+export function maybeCompleteAuthSession(): void {}

package/vendor/node_modules/@legendapp/spark-auth-session/src/index.web.ts

@@ -0,0 +1 @@
+export * from "./mobile";

package/vendor/node_modules/@legendapp/spark-auth-session/src/mobile.ts

@@ -0,0 +1,52 @@
+import * as Browser from "expo-web-browser";
+import * as Crypto from "expo-crypto";
+import { authorize, callbackMatches, timeout, validateRedirect, validateCount, validateDigest, type AuthSession, type AuthSessionOptions, type AuthSessionResult } from "./types";
+export type * from "./types";
+export function getRandomBytesAsync(count: number) { validateCount(count); return Crypto.getRandomBytesAsync(count); }
+export function digestStringAsync(algorithm: "SHA-256", value: string) { validateDigest(algorithm, value); return Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, value); }
+let busy = false;
+/** On web, invoke this on the redirect page so Expo can complete its popup session. */
+export const maybeCompleteAuthSession = Browser.maybeCompleteAuthSession;
+export async function createAuthSession(options: AuthSessionOptions = {}): Promise<AuthSession> {
+  const duration = timeout(options);
+  if (!options.redirectUri) throw new TypeError("Mobile/web authentication requires an explicit registered redirectUri");
+  const redirectUri = options.redirectUri; validateRedirect(redirectUri);
+  if (busy) throw Object.assign(new Error("An authentication session is already active"), { code: "E_BUSY" });
+  if (options.signal?.aborted) throw Object.assign(new Error("Authentication was cancelled"), { name: "AbortError" });
+  busy = true;
+  try {
+    const state = Array.from(await getRandomBytesAsync(32), byte => byte.toString(16).padStart(2, "0")).join("");
+    let closed = false, opened = false;
+    let resolve!: (value: AuthSessionResult) => void;
+    const result = new Promise<AuthSessionResult>(done => { resolve = done; });
+    const finish = (value: AuthSessionResult) => {
+      if (closed) return; closed = true; clearTimeout(timer); options.signal?.removeEventListener("abort", cancel); busy = false;
+      if (opened) { try { Browser.dismissAuthSession(); } catch { /* Android custom tabs may remain visible. */ } }
+      resolve(value);
+    };
+    const cancel = () => finish({ type: "cancel" });
+    const timer = setTimeout(() => finish({ type: "timeout" }), duration);
+    options.signal?.addEventListener("abort", cancel, { once: true });
+    if (options.signal?.aborted) cancel();
+    return {
+      state, redirectUri,
+      async open(url) {
+        if (opened) throw new Error("Auth sessions can only be opened once");
+        if (closed) return result;
+        try {
+          authorize(url, state, redirectUri); opened = true;
+          // Call synchronously within the user's gesture on web; do not await preparation here.
+          const browser = Browser.openAuthSessionAsync(url, redirectUri).then(value => {
+            if (closed) return;
+            if (value.type === "success") {
+              if (!callbackMatches(value.url, redirectUri, state)) throw new Error("Authentication callback state or redirect did not match");
+              finish({ type: "success", url: value.url });
+            } else finish({ type: value.type === "cancel" ? "cancel" : "dismiss" });
+          });
+          return await Promise.race([result, browser.then(() => result)]);
+        } catch (error) { finish({ type: "dismiss" }); throw error; }
+      },
+      async dismiss() { finish({ type: "dismiss" }); },
+    };
+  } catch (error) { busy = false; throw error; }
+}