@legendapp/spark 0.0.1-next.2

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

@@ -0,0 +1,295 @@
+#pragma once
+#include "NativeModules.h"
+#include <shlobj.h>
+#include <shlwapi.h>
+#include <winrt/Windows.Data.Json.h>
+#include <winrt/Windows.Security.Cryptography.h>
+#include <winrt/Windows.Storage.Streams.h>
+#include <filesystem>
+#include <algorithm>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <deque>
+#include <functional>
+#include <map>
+#include <vector>
+#include <algorithm>
+#include <climits>
+#include <cmath>
+#include "Trash.h"
+#pragma comment(lib, "Ole32.lib")
+#pragma comment(lib, "Shell32.lib")
+#pragma comment(lib, "Shlwapi.lib")
+
+namespace winrt::SparkFileSystem {
+namespace React = Microsoft::ReactNative;
+namespace Json = Windows::Data::Json;
+namespace fs = std::filesystem;
+using Crypto = Windows::Security::Cryptography::CryptographicBuffer;
+
+inline fs::path FilePath(hstring const &input) {
+  std::wstring value(input);
+  if (value.empty() || value.find(L'\0') != std::wstring::npos) throw hresult_invalid_argument(L"Expected an absolute path or file URL");
+  if (value.starts_with(L"file://")) {
+    Windows::Foundation::Uri uri(input);
+    if ((!uri.Host().empty() && uri.Host() != L"localhost") || !uri.Query().empty() || !uri.Fragment().empty())
+      throw hresult_invalid_argument(L"Expected a local file URL without a query or fragment");
+    std::vector<wchar_t> decoded(32768); DWORD length = static_cast<DWORD>(decoded.size());
+    check_hresult(PathCreateFromUrlW(value.c_str(), decoded.data(), &length, 0)); value.assign(decoded.data());
+  }
+  // Device namespaces are not ordinary filesystem paths. Extended drive/UNC paths are supported.
+  if (value.starts_with(L"\\\\.\\") || (value.starts_with(L"\\\\?\\") &&
+      !(value.size() > 6 && value[5] == L':' && value[6] == L'\\') && !value.starts_with(L"\\\\?\\UNC\\")))
+    throw hresult_invalid_argument(L"Expected a filesystem path");
+  fs::path result(value);
+  if (!result.is_absolute()) throw hresult_invalid_argument(L"Expected an absolute path");
+  return result;
+}
+inline std::string PathString(fs::path const &path) { return to_string(path.wstring()); }
+inline std::string ErrorCode(DWORD error) {
+  switch (error) {
+    case ERROR_FILE_NOT_FOUND: case ERROR_PATH_NOT_FOUND: return "E_NOT_FOUND";
+    case ERROR_ACCESS_DENIED: case ERROR_PRIVILEGE_NOT_HELD: return "E_PERMISSION";
+    case ERROR_ALREADY_EXISTS: case ERROR_FILE_EXISTS: return "E_EXISTS";
+    case ERROR_DIR_NOT_EMPTY: return "E_NOT_EMPTY";
+    case ERROR_INVALID_HANDLE: return "E_CLOSED";
+    case ERROR_INVALID_PARAMETER: case ERROR_INVALID_NAME: return "E_INVALID_ARGUMENT";
+    default: return "E_IO";
+  }
+}
+inline void Reject(React::ReactPromise<std::string> const &promise) noexcept {
+  try { throw; }
+  catch (fs::filesystem_error const &e) {
+    auto code = e.code(); std::string kind = "E_IO";
+    if (code == std::errc::no_such_file_or_directory) kind = "E_NOT_FOUND";
+    else if (code == std::errc::permission_denied) kind = "E_PERMISSION";
+    else if (code == std::errc::file_exists) kind = "E_EXISTS";
+    else if (code == std::errc::directory_not_empty) kind = "E_NOT_EMPTY";
+    promise.Reject(React::ReactError{kind, e.what()});
+  } catch (hresult_error const &e) {
+    promise.Reject(React::ReactError{e.code() == E_INVALIDARG ? "E_INVALID_ARGUMENT" : ErrorCode(HRESULT_CODE(e.code())), to_string(e.message())});
+  } catch (std::exception const &e) { promise.Reject(React::ReactError{"E_IO", e.what()}); }
+  catch (...) { promise.Reject(React::ReactError{"E_IO", "Filesystem operation failed"}); }
+}
+inline handle Open(fs::path const &path, DWORD access, DWORD creation, DWORD flags = FILE_ATTRIBUTE_NORMAL) {
+  auto raw = CreateFileW(path.c_str(), access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, creation, flags, nullptr);
+  if (raw == INVALID_HANDLE_VALUE) throw_last_error();
+  return handle(raw);
+}
+inline std::vector<uint8_t> Read(fs::path const &path) {
+  auto file = Open(path, GENERIC_READ, OPEN_EXISTING);
+  std::vector<uint8_t> data; uint8_t buffer[65536]; DWORD count;
+  do {
+    if (!ReadFile(file.get(), buffer, sizeof(buffer), &count, nullptr)) throw_last_error();
+    data.insert(data.end(), buffer, buffer + count);
+  } while (count);
+  return data;
+}
+inline void Write(fs::path const &path, std::vector<uint8_t> const &data) {
+  GUID guid{}; check_hresult(CoCreateGuid(&guid)); wchar_t id[40]{}; StringFromGUID2(guid, id, 40);
+  auto temporary = path.parent_path() / (std::wstring(L".spark-") + id);
+  try {
+    auto file = Open(temporary, GENERIC_WRITE, CREATE_NEW);
+    for (size_t offset = 0; offset < data.size();) {
+      DWORD count = 0, requested = static_cast<DWORD>((std::min)(data.size() - offset, size_t(65536)));
+      if (!WriteFile(file.get(), data.data() + offset, requested, &count, nullptr) || !count) throw_last_error();
+      offset += count;
+    }
+    if (!FlushFileBuffers(file.get())) throw_last_error(); file.close();
+    if (!MoveFileExW(temporary.c_str(), path.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) throw_last_error();
+  } catch (...) { std::error_code ignored; fs::remove(temporary, ignored); throw; }
+}
+inline fs::path Directory(hstring const &kind) {
+  wchar_t identity[201]{}; auto count = GetEnvironmentVariableW(L"SPARK_PROJECT_ID", identity, 201);
+  if (!count || count >= 201) throw hresult_invalid_argument(L"Launch through Spark to establish project storage identity");
+  // Hex encoding is injective and cannot introduce separators or reserved device names.
+  std::wstring project; constexpr wchar_t hex[] = L"0123456789abcdef";
+  for (auto byte : to_string(hstring(identity))) { project += hex[(static_cast<unsigned char>(byte) >> 4) & 15]; project += hex[byte & 15]; }
+  fs::path base;
+  if (kind == L"temp") {
+    std::vector<wchar_t> value(32768); auto size = GetTempPathW(static_cast<DWORD>(value.size()), value.data());
+    if (!size || size >= value.size()) throw_last_error(); base = value.data();
+  } else if (kind == L"data" || kind == L"cache") {
+    PWSTR value = nullptr; check_hresult(SHGetKnownFolderPath(FOLDERID_LocalAppData, KF_FLAG_CREATE, nullptr, &value));
+    base = value; CoTaskMemFree(value);
+  } else throw hresult_invalid_argument(L"Unknown directory kind");
+  // Split long identities into components to stay below NTFS's filename limit.
+  base /= L"Spark"; for (size_t i = 0; i < project.size(); i += 100) base /= project.substr(i, 100);
+  base /= kind.c_str(); fs::create_directories(base); return base;
+}
+
+// Invalidation: a file watches its parent so atomic replacement does
+// not detach the subscription. Signals may include sibling changes, as on macOS.
+struct Watch {
+  std::vector<HANDLE> notifications;
+  handle stop{CreateEventW(nullptr, TRUE, FALSE, nullptr)};
+  std::thread thread;
+  Watch(fs::path const &path, std::string id, React::ReactContext context, bool recursive) {
+    if (!stop) throw_last_error();
+    if (recursive && !fs::is_directory(path)) throw hresult_invalid_argument(L"Recursive watch requires an existing directory");
+    const auto observed = fs::is_directory(path) ? path : path.parent_path();
+    auto observe = [this](fs::path const &directory, bool subtree) {
+      auto handle = FindFirstChangeNotificationW(directory.c_str(), subtree,
+        FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE);
+      if (handle == INVALID_HANDLE_VALUE) throw_last_error();
+      notifications.push_back(handle);
+    };
+    try {
+      observe(observed, recursive);
+      // A directory's own rename/deletion changes its parent, not its contents.
+      // Keep that invalidation too; as on macOS, listeners must re-read the path.
+      if (observed.has_parent_path() && observed.parent_path() != observed) observe(observed.parent_path(), recursive);
+      thread = std::thread([this, id, context, path = PathString(path)] {
+        init_apartment(apartment_type::multi_threaded);
+        std::vector<HANDLE> signals{stop.get()}; signals.insert(signals.end(), notifications.begin(), notifications.end());
+        for (;;) {
+          auto result = WaitForMultipleObjects(static_cast<DWORD>(signals.size()), signals.data(), FALSE, INFINITE);
+          if (result < WAIT_OBJECT_0 + 1 || result >= WAIT_OBJECT_0 + signals.size()) break;
+          const bool rearmed = FindNextChangeNotification(signals[result - WAIT_OBJECT_0]) != FALSE;
+          if (WaitForSingleObject(stop.get(), 0) != WAIT_TIMEOUT) break;
+          context.EmitJSEvent(L"RCTDeviceEventEmitter", L"change", React::JSValueObject{{"id", id}, {"path", path}});
+          if (!rearmed) {
+            const auto index = result - WAIT_OBJECT_0;
+            auto failed = signals[index]; signals.erase(signals.begin() + index);
+            notifications.erase(std::remove(notifications.begin(), notifications.end(), failed), notifications.end());
+            FindCloseChangeNotification(failed);
+            if (signals.size() == 1) break;
+          }
+        }
+        uninit_apartment();
+      });
+    } catch (...) { for (auto handle : notifications) FindCloseChangeNotification(handle); throw; }
+  }
+  ~Watch() { SetEvent(stop.get()); if (thread.joinable()) thread.join(); for (auto handle : notifications) FindCloseChangeNotification(handle); }
+};
+struct FileQueue {
+  React::ReactContext context;
+  std::mutex mutex; std::condition_variable ready; bool stopping = false;
+  std::deque<std::function<void()>> pending;
+  std::map<std::string, std::unique_ptr<Watch>> watches;
+  std::map<std::string, handle> files;
+  std::thread worker;
+  explicit FileQueue(React::ReactContext value) : context(value), worker([this] {
+    init_apartment(apartment_type::multi_threaded);
+    for (;;) {
+      std::function<void()> action;
+      { std::unique_lock lock(mutex); ready.wait(lock, [this] { return stopping || !pending.empty(); });
+        if (pending.empty()) break; action = std::move(pending.front()); pending.pop_front(); }
+      action();
+    }
+    files.clear(); watches.clear(); uninit_apartment();
+  }) {}
+  ~FileQueue() { { std::lock_guard lock(mutex); stopping = true; } ready.notify_one(); worker.join(); }
+  void Post(std::function<void()> action) { { std::lock_guard lock(mutex); pending.push_back(std::move(action)); } ready.notify_one(); }
+  Json::IJsonValue Call(std::string const &method, Json::JsonObject const &args) {
+    if (method == "directory") return Json::JsonValue::CreateStringValue(Directory(args.GetNamedString(L"kind")).wstring());
+    if (method == "unwatch") { watches.erase(to_string(args.GetNamedString(L"id"))); return Json::JsonValue::Parse(L"null"); }
+    if (method == "closeFile") { files.erase(to_string(args.GetNamedString(L"id"))); return Json::JsonValue::Parse(L"null"); }
+    if (method == "readChunk" || method == "writeChunk" || method == "flushFile") {
+      auto found = files.find(to_string(args.GetNamedString(L"id")));
+      if (found == files.end()) throw hresult_error(HRESULT_FROM_WIN32(ERROR_INVALID_HANDLE), L"Unknown or closed file handle");
+      auto file = found->second.get();
+      if (method == "flushFile") { if (!FlushFileBuffers(file)) throw_last_error(); return Json::JsonValue::Parse(L"null"); }
+      double offset = args.GetNamedNumber(L"offset");
+      if (!std::isfinite(offset) || offset < 0 || std::floor(offset) != offset || offset > 9007199254740991.0) throw hresult_invalid_argument(L"Invalid file offset");
+      LARGE_INTEGER position{}; position.QuadPart = static_cast<LONGLONG>(offset);
+      if (!SetFilePointerEx(file, position, nullptr, FILE_BEGIN)) throw_last_error();
+      if (method == "readChunk") {
+        double length = args.GetNamedNumber(L"length");
+        if (!std::isfinite(length) || length < 1 || length > 1048576 || std::floor(length) != length || offset + length > 9007199254740991.0) throw hresult_invalid_argument(L"Invalid chunk length");
+        std::vector<uint8_t> data(static_cast<size_t>(length)); DWORD count = 0;
+        if (!ReadFile(file, data.data(), static_cast<DWORD>(data.size()), &count, nullptr)) throw_last_error();
+        data.resize(count); return Json::JsonValue::CreateStringValue(Crypto::EncodeToBase64String(Crypto::CreateFromByteArray(data)));
+      }
+      auto base64 = args.GetNamedString(L"base64");
+      if (base64.size() > 1398104) throw hresult_invalid_argument(L"Chunk exceeds 1 MiB");
+      auto buffer = Crypto::DecodeFromBase64String(base64);
+      if (Crypto::EncodeToBase64String(buffer) != base64 || buffer.Length() > 1048576 || offset + buffer.Length() > 9007199254740991.0) throw hresult_invalid_argument(L"Invalid chunk");
+      com_array<uint8_t> data; Crypto::CopyToByteArray(buffer, data);
+      size_t written = 0;
+      while (written < data.size()) { DWORD count = 0; if (!WriteFile(file, data.data() + written, static_cast<DWORD>(data.size() - written), &count, nullptr)) throw_last_error(); if (!count) throw hresult_error(E_FAIL, L"File write made no progress"); written += count; }
+      return Json::JsonValue::CreateNumberValue(static_cast<double>(written));
+    }
+    auto path = FilePath(args.GetNamedString(L"path"));
+    if (method == "openFile") {
+      auto mode = args.GetNamedString(L"mode"); DWORD access, creation;
+      if (mode == L"read") { access = GENERIC_READ; creation = OPEN_EXISTING; }
+      else if (mode == L"readWrite") { access = GENERIC_READ | GENERIC_WRITE; creation = OPEN_EXISTING; }
+      else if (mode == L"write") { access = GENERIC_WRITE; creation = OPEN_ALWAYS; }
+      else if (mode == L"createNew") { access = GENERIC_WRITE; creation = CREATE_NEW; }
+      else throw hresult_invalid_argument(L"Invalid file mode");
+      auto file = Open(path, access, creation);
+      BY_HANDLE_FILE_INFORMATION info{}; if (!GetFileInformationByHandle(file.get(), &info)) throw_last_error();
+      if (GetFileType(file.get()) != FILE_TYPE_DISK || (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) throw hresult_invalid_argument(L"Expected a regular file");
+      if (mode == L"write" && !SetEndOfFile(file.get())) throw_last_error();
+      GUID guid{}; check_hresult(CoCreateGuid(&guid)); wchar_t identifier[40]{}; StringFromGUID2(guid, identifier, 40);
+      files.emplace(to_string(hstring(identifier)), std::move(file)); return Json::JsonValue::CreateStringValue(identifier);
+    }
+    if (method == "trash") { Trash(path); return Json::JsonValue::Parse(L"null"); }
+    if (method == "readText") {
+      const auto bytes = Read(path); std::string text(bytes.begin(), bytes.end());
+      if (text.starts_with("\xef\xbb\xbf")) text.erase(0, 3);
+      // Reject malformed UTF-8 before WinRT conversion can replace bytes.
+      if (text.size() > INT_MAX) throw hresult_error(E_FAIL, L"Text exceeds the UTF-8 conversion limit");
+      if (!text.empty() && !MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, text.data(), static_cast<int>(text.size()), nullptr, 0)) throw_last_error();
+      return Json::JsonValue::CreateStringValue(to_hstring(text));
+    } else if (method == "readBytes") return Json::JsonValue::CreateStringValue(Crypto::EncodeToBase64String(Crypto::CreateFromByteArray(Read(path))));
+    else if (method == "writeText") { auto text = to_string(args.GetNamedString(L"text")); Write(path, std::vector<uint8_t>(text.begin(), text.end())); }
+    else if (method == "writeBytes") {
+      auto base64 = args.GetNamedString(L"base64"); Windows::Storage::Streams::IBuffer buffer{nullptr};
+      try { buffer = base64.empty() ? Crypto::CreateFromByteArray(array_view<uint8_t const>{}) : Crypto::DecodeFromBase64String(base64); } catch (hresult_error const &) { throw hresult_invalid_argument(L"Invalid base64 data"); }
+      if (Crypto::EncodeToBase64String(buffer) != base64) throw hresult_invalid_argument(L"Invalid base64 data");
+      com_array<uint8_t> data; Crypto::CopyToByteArray(buffer, data); Write(path, std::vector<uint8_t>(data.begin(), data.end()));
+    } else if (method == "mkdir") {
+      if (args.GetNamedBoolean(L"recursive", true)) fs::create_directories(path);
+      else if (!fs::create_directory(path)) throw hresult_error(HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS));
+    } else if (method == "remove") {
+      if (args.GetNamedBoolean(L"recursive", false)) return Json::JsonValue::CreateBooleanValue(fs::remove_all(path) != 0);
+      return Json::JsonValue::CreateBooleanValue(fs::remove(path));
+    } else if (method == "copy" || method == "move") {
+      auto to = FilePath(args.GetNamedString(L"to"));
+      auto destination = fs::symlink_status(to);
+      if (destination.type() != fs::file_type::not_found) throw hresult_error(HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS));
+      if (method == "copy") fs::copy(path, to, fs::copy_options::recursive | fs::copy_options::copy_symlinks);
+      else if (!MoveFileExW(path.c_str(), to.c_str(), MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH)) {
+        if (GetLastError() != ERROR_NOT_SAME_DEVICE || !fs::is_directory(path)) throw_last_error();
+        try { fs::copy(path, to, fs::copy_options::recursive | fs::copy_options::copy_symlinks); }
+        catch (...) { std::error_code ignored; fs::remove_all(to, ignored); throw; }
+        fs::remove_all(path);
+      }
+    } else if (method == "stat") {
+      // OPEN_REPARSE_POINT describes a link itself, including dangling links.
+      auto file = Open(path, FILE_READ_ATTRIBUTES, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT);
+      BY_HANDLE_FILE_INFORMATION info{}; if (!GetFileInformationByHandle(file.get(), &info)) throw_last_error();
+      ULARGE_INTEGER time{}; time.LowPart = info.ftLastWriteTime.dwLowDateTime; time.HighPart = info.ftLastWriteTime.dwHighDateTime;
+      Json::JsonObject result;
+      result.SetNamedValue(L"type", Json::JsonValue::CreateStringValue(fs::is_symlink(fs::symlink_status(path)) ? L"symlink" : (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? L"directory" : L"file"));
+      result.SetNamedValue(L"size", Json::JsonValue::CreateNumberValue(static_cast<double>((uint64_t(info.nFileSizeHigh) << 32) | info.nFileSizeLow)));
+      result.SetNamedValue(L"modifiedAt", Json::JsonValue::CreateNumberValue(static_cast<double>(time.QuadPart) / 10000.0 - 11644473600000.0)); return result;
+    } else if (method == "list") {
+      std::vector<std::wstring> names; for (auto const &item : fs::directory_iterator(path)) names.push_back(item.path().filename().wstring());
+      std::sort(names.begin(), names.end()); Json::JsonArray result;
+      for (auto const &name : names) result.Append(Json::JsonValue::CreateStringValue(name)); return result;
+    } else if (method == "watch") {
+      auto id = to_string(args.GetNamedString(L"id"));
+      if (id.empty() || watches.count(id)) throw hresult_invalid_argument(L"Watch id must be unique and nonempty");
+      watches.emplace(id, std::make_unique<Watch>(path, id, context, args.GetNamedBoolean(L"recursive", false)));
+    } else throw hresult_invalid_argument(L"Unknown filesystem operation");
+    return Json::JsonValue::Parse(L"null");
+  }
+};
+REACT_MODULE(SparkFileSystem, L"NativeDesktopFileSystem")
+struct SparkFileSystem {
+  std::unique_ptr<FileQueue> queue;
+  REACT_INIT(Initialize) void Initialize(React::ReactContext const &context) noexcept { queue = std::make_unique<FileQueue>(context); }
+  REACT_METHOD(call) void call(std::string method, std::string args, React::ReactPromise<std::string> promise) noexcept {
+    queue->Post([state = queue.get(), method, args, promise] {
+      try { promise.Resolve(to_string(state->Call(method, Json::JsonObject::Parse(to_hstring(args))).Stringify())); }
+      catch (...) { Reject(promise); }
+    });
+  }
+  REACT_METHOD(addListener) void addListener(std::string) noexcept {}
+  REACT_METHOD(removeListeners) void removeListeners(double) noexcept {}
+};
+}

package/vendor/node_modules/@legendapp/spark-file-system/windows/SparkFileSystem/SparkFileSystem.vcxproj

@@ -0,0 +1,144 @@
+<?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>{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}</ProjectGuid>
+    <ProjectName>SparkFileSystem</ProjectName>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>SparkFileSystem</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>SparkFileSystem.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="Trash.h" />
+    <ClInclude Include="SparkFileSystem.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="SparkFileSystem.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="SparkFileSystem.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-file-system/windows/SparkFileSystem/SparkFileSystem.vcxproj.filters

@@ -0,0 +1,45 @@
+<?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="Trash.h" />
+    <ClInclude Include="SparkFileSystem.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="pch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="SparkFileSystem.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="SparkFileSystem.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>

package/vendor/node_modules/@legendapp/spark-file-system/windows/SparkFileSystem/Trash.h

@@ -0,0 +1,52 @@
+#pragma once
+#include <shobjidl.h>
+#include <wrl.h>
+#include <thread>
+#include <exception>
+
+namespace winrt::SparkFileSystem {
+// The shell can choose permanent deletion even when recycling was requested.
+// Veto that choice before any deletion, including on network/removable volumes.
+struct RecycleGuard final : Microsoft::WRL::RuntimeClass<Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom>, IFileOperationProgressSink> {
+  HRESULT result = E_ABORT;
+  bool completed = false;
+  IFACEMETHODIMP PreDeleteItem(DWORD flags, IShellItem *) override { return (flags & TSF_DELETE_RECYCLE_IF_POSSIBLE) ? S_OK : E_ABORT; }
+  IFACEMETHODIMP PostDeleteItem(DWORD, IShellItem *, HRESULT status, IShellItem *) override { result = status; completed = true; return S_OK; }
+  IFACEMETHODIMP StartOperations() override { return S_OK; }
+  IFACEMETHODIMP FinishOperations(HRESULT) override { return S_OK; }
+  IFACEMETHODIMP UpdateProgress(UINT, UINT) override { return S_OK; }
+  IFACEMETHODIMP ResetTimer() override { return S_OK; }
+  IFACEMETHODIMP PauseTimer() override { return S_OK; }
+  IFACEMETHODIMP ResumeTimer() override { return S_OK; }
+  IFACEMETHODIMP PreRenameItem(DWORD, IShellItem *, LPCWSTR) override { return E_NOTIMPL; }
+  IFACEMETHODIMP PostRenameItem(DWORD, IShellItem *, LPCWSTR, HRESULT, IShellItem *) override { return E_NOTIMPL; }
+  IFACEMETHODIMP PreMoveItem(DWORD, IShellItem *, IShellItem *, LPCWSTR) override { return E_NOTIMPL; }
+  IFACEMETHODIMP PostMoveItem(DWORD, IShellItem *, IShellItem *, LPCWSTR, HRESULT, IShellItem *) override { return E_NOTIMPL; }
+  IFACEMETHODIMP PreCopyItem(DWORD, IShellItem *, IShellItem *, LPCWSTR) override { return E_NOTIMPL; }
+  IFACEMETHODIMP PostCopyItem(DWORD, IShellItem *, IShellItem *, LPCWSTR, HRESULT, IShellItem *) override { return E_NOTIMPL; }
+  IFACEMETHODIMP PreNewItem(DWORD, IShellItem *, LPCWSTR) override { return E_NOTIMPL; }
+  IFACEMETHODIMP PostNewItem(DWORD, IShellItem *, LPCWSTR, LPCWSTR, DWORD, HRESULT, IShellItem *) override { return E_NOTIMPL; }
+};
+inline void Trash(std::filesystem::path const &path) {
+  std::exception_ptr failure;
+  std::thread sta([&] {
+    auto initialized = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);
+    if (FAILED(initialized)) { failure = std::make_exception_ptr(hresult_error(initialized)); return; }
+    try {
+      com_ptr<IFileOperation> operation;
+      check_hresult(CoCreateInstance(CLSID_FileOperation, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(operation.put())));
+      check_hresult(operation->SetOperationFlags(FOF_SILENT | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_ALLOWUNDO | FOFX_RECYCLEONDELETE | FOFX_EARLYFAILURE));
+      com_ptr<IShellItem> item;
+      check_hresult(SHCreateItemFromParsingName(path.c_str(), nullptr, IID_PPV_ARGS(item.put())));
+      auto guard = Microsoft::WRL::Make<RecycleGuard>();
+      check_hresult(operation->DeleteItem(item.get(), guard.Get()));
+      check_hresult(operation->PerformOperations());
+      BOOL aborted = FALSE; check_hresult(operation->GetAnyOperationsAborted(&aborted));
+      if (aborted || !guard->completed) throw hresult_error(E_ABORT, L"Item could not be recycled; permanent deletion was refused");
+      check_hresult(guard->result);
+    } catch (...) { failure = std::current_exception(); }
+    CoUninitialize();
+  });
+  sta.join(); if (failure) std::rethrow_exception(failure);
+}
+}

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

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

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

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

package/vendor/node_modules/@legendapp/spark-file-system/windows/SparkFileSystem/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-file-system/windows/SparkFileSystem.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}") = "SparkFileSystem", "SparkFileSystem\SparkFileSystem.vcxproj", "{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}"
+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
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Debug|x64.ActiveCfg = Debug|x64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Debug|x64.Build.0 = Debug|x64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Debug|x64.Deploy.0 = Debug|x64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Debug|x86.ActiveCfg = Debug|Win32
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Debug|x86.Build.0 = Debug|Win32
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Debug|x86.Deploy.0 = Debug|Win32
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Debug|ARM64.Build.0 = Debug|ARM64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Debug|ARM64.Deploy.0 = Debug|ARM64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Release|x64.ActiveCfg = Release|x64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Release|x64.Build.0 = Release|x64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Release|x64.Deploy.0 = Release|x64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Release|x86.ActiveCfg = Release|Win32
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Release|x86.Build.0 = Release|Win32
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Release|x86.Deploy.0 = Release|Win32
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Release|ARM64.ActiveCfg = Release|ARM64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Release|ARM64.Build.0 = Release|ARM64
+		{1DFD2919-6543-4CC4-8F0C-A864BFB5050C}.Release|ARM64.Deploy.0 = Release|ARM64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {E8F1617F-F0A1-46B8-9AF8-6B6980AC2208}
+	EndGlobalSection
+EndGlobal