@legendapp/spark 0.0.1-next.2 → 0.0.1-next.3

package/vendor/node_modules/@legendapp/spark-file-dialog/windows/SparkFileDialog/SparkFileDialog.h

@@ -7,7 +7,6 @@
 #pragma comment(lib, "Shlwapi.lib")
 #include <winrt/Windows.Data.Json.h>
 #include <filesystem>
-#include <fstream>
 #include <vector>
 #pragma comment(lib, "Ole32.lib")
 namespace winrt::SparkFileDialog {
@@ -18,29 +17,6 @@ inline std::filesystem::path FilePath(std::string const &value) {
   if (!result.is_absolute() || value.find('\0') != std::string::npos) throw hresult_invalid_argument(L"Expected an absolute file path");
   return result;
 }
-inline std::string Read(std::string const &value) {
-  auto file = FilePath(value);
-  if (std::filesystem::file_size(file) > 8 * 1024 * 1024) throw hresult_invalid_argument(L"This text editor supports files up to 8 MB");
-  std::ifstream input(file, std::ios::binary);
-  if (!input) throw hresult_error(E_FAIL, L"Could not read file");
-  std::string text((std::istreambuf_iterator<char>(input)), std::istreambuf_iterator<char>());
-  if (input.bad()) throw hresult_error(E_FAIL, L"File read failed");
-  if (text.starts_with("\xef\xbb\xbf")) text.erase(0, 3);
-  // Reject non-UTF-8 input instead of silently destroying its encoding on save.
-  (void)to_hstring(text);
-  return text;
-}
-inline void Write(std::string const &value, std::string const &contents) {
-  auto file = FilePath(value);
-  GUID guid{}; check_hresult(CoCreateGuid(&guid));
-  wchar_t id[40]{}; StringFromGUID2(guid, id, 40);
-  auto temporary = file; temporary += std::wstring(L".spark-") + id;
-  try {
-    { std::ofstream output(temporary, std::ios::binary | std::ios::trunc);
-      output.exceptions(std::ios::badbit | std::ios::failbit); output.write(contents.data(), contents.size()); output.close(); }
-    if (!MoveFileExW(temporary.c_str(), file.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) throw_last_error();
-  } catch (...) { std::error_code ignored; std::filesystem::remove(temporary, ignored); throw; }
-}
 REACT_MODULE(SparkFileDialog, L"NativeFileDialog")
 struct SparkFileDialog {
   React::ReactContext context;
@@ -54,6 +30,18 @@ struct SparkFileDialog {
     context.UIDispatcher().Post([save, options, promise]() {
       try {
         auto args = Json::JsonObject::Parse(to_hstring(options));
+        HWND parent = nullptr;
+        if (args.HasKey(L"windowId")) {
+          struct Search { std::wstring property; HWND found = nullptr; } search{L"Spark.Window." + std::wstring(args.GetNamedString(L"windowId"))};
+          EnumWindows([](HWND hwnd, LPARAM value) -> BOOL {
+            auto search = reinterpret_cast<Search *>(value); DWORD process = 0; GetWindowThreadProcessId(hwnd, &process);
+            if (process == GetCurrentProcessId() && GetPropW(hwnd, search->property.c_str())) { search->found = hwnd; return FALSE; }
+            return TRUE;
+          }, reinterpret_cast<LPARAM>(&search));
+          parent = search.found;
+          if (!parent) { promise.Reject(React::ReactError{"E_NOT_FOUND", "Dialog owner does not exist"}); return; }
+          if (!IsWindowEnabled(parent)) { promise.Reject(React::ReactError{"E_BUSY", "Dialog owner already has a modal operation"}); return; }
+        }
         com_ptr<IFileDialog> dialog;
         check_hresult(CoCreateInstance(save ? CLSID_FileSaveDialog : CLSID_FileOpenDialog, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(dialog.put())));
         DWORD flags{}; check_hresult(dialog->GetOptions(&flags));
@@ -67,21 +55,43 @@ struct SparkFileDialog {
         const auto message = args.GetNamedString(L"message", L"");
         if (!message.empty()) { auto custom = dialog.as<IFileDialogCustomize>(); check_hresult(custom->AddText(100, message.c_str())); }
         auto directory = args.GetNamedString(save ? L"directory" : L"directoryURL", L"");
+        std::wstring suggestedName = args.GetNamedString(L"defaultName", L"");
         if (!directory.empty()) {
           std::wstring value(directory);
           if (value.rfind(L"file:", 0) == 0) { wchar_t buffer[32768]; DWORD length = 32768; check_hresult(PathCreateFromUrlW(value.c_str(), buffer, &length, 0)); value = buffer; }
+          // defaultPath may name a file for save dialogs: a live directory starts the
+          // panel; otherwise the last component suggests defaultName and the parent starts it.
+          if (save && GetFileAttributesW(value.c_str()) == INVALID_FILE_ATTRIBUTES) {
+            auto parsed = std::filesystem::path(value);
+            auto parent = parsed.parent_path();
+            if (suggestedName.empty()) suggestedName = parsed.filename().wstring();
+            if (!parent.empty()) value = parent.wstring();
+          }
           auto folder = FilePath(to_string(value)); com_ptr<IShellItem> item;
           check_hresult(SHCreateItemFromParsingName(folder.c_str(), nullptr, IID_PPV_ARGS(item.put())));
           check_hresult(dialog->SetFolder(item.get()));
         }
-        const auto name = args.GetNamedString(L"defaultName", L"Untitled.txt"); if (save) check_hresult(dialog->SetFileName(name.c_str()));
-        std::vector<std::wstring> patterns;
-        if (args.HasKey(L"allowedFileTypes")) for (auto const &item : args.GetNamedArray(L"allowedFileTypes")) patterns.push_back(L"*." + std::wstring(item.GetString()));
-        std::wstring pattern;
-        for (auto const &item : patterns) { if (!pattern.empty()) pattern += L";"; pattern += item; }
-        COMDLG_FILTERSPEC filter{L"Supported files", pattern.c_str()};
-        if (!pattern.empty()) check_hresult(dialog->SetFileTypes(1, &filter));
-        auto status = dialog->Show(GetActiveWindow());
+        if (save) check_hresult(dialog->SetFileName(suggestedName.empty() ? L"Untitled.txt" : suggestedName.c_str()));
+        // Windows presents one labeled filter group per filter, like Electron;
+        // hosts without per-filter labels read the flattened allowedFileTypes.
+        std::vector<std::wstring> labels, patterns;
+        if (args.HasKey(L"filters")) for (auto const &item : args.GetNamedArray(L"filters")) {
+          auto filter = item.GetObject();
+          std::wstring pattern;
+          for (auto const &extension : filter.GetNamedArray(L"extensions")) { if (!pattern.empty()) pattern += L";"; pattern += L"*." + std::wstring(extension.GetString()); }
+          if (pattern.empty()) continue;
+          labels.push_back(filter.HasKey(L"name") ? std::wstring(filter.GetNamedString(L"name")) : std::wstring(L"Supported files"));
+          patterns.push_back(pattern);
+        }
+        else if (args.HasKey(L"allowedFileTypes")) {
+          std::wstring pattern;
+          for (auto const &item : args.GetNamedArray(L"allowedFileTypes")) { if (!pattern.empty()) pattern += L";"; pattern += L"*." + std::wstring(item.GetString()); }
+          if (!pattern.empty()) { labels.push_back(L"Supported files"); patterns.push_back(pattern); }
+        }
+        std::vector<COMDLG_FILTERSPEC> filterSpecs;
+        for (size_t index = 0; index < patterns.size(); ++index) filterSpecs.push_back(COMDLG_FILTERSPEC{labels[index].c_str(), patterns[index].c_str()});
+        if (!filterSpecs.empty()) check_hresult(dialog->SetFileTypes(static_cast<UINT>(filterSpecs.size()), filterSpecs.data()));
+        auto status = dialog->Show(parent);
         if (status == HRESULT_FROM_WIN32(ERROR_CANCELLED)) { promise.Resolve("null"); return; }
         check_hresult(status);
         auto pathFor = [](IShellItem *item) {
@@ -98,31 +108,5 @@ struct SparkFileDialog {
       } catch (hresult_error const &error) { promise.Reject(React::ReactError{"E_DIALOG", to_string(error.message())}); }
     });
   }
-  REACT_METHOD(readTextFile)
-  void readTextFile(std::string file, React::ReactPromise<std::string> promise) noexcept {
-    try { promise.Resolve(Read(file)); } catch (std::exception const &error) { promise.Reject(error.what()); } catch (hresult_error const &error) { promise.Reject(to_string(error.message()).c_str()); }
-  }
-  REACT_METHOD(writeTextFile)
-  void writeTextFile(std::string file, std::string contents, React::ReactPromise<void> promise) noexcept {
-    try { Write(file, contents); promise.Resolve(); } catch (std::exception const &error) { promise.Reject(error.what()); } catch (hresult_error const &error) { promise.Reject(to_string(error.message()).c_str()); }
-  }
-  REACT_METHOD(writeTextFileIfUnchanged)
-  void writeTextFileIfUnchanged(std::string file, std::string expected, std::string contents, React::ReactPromise<bool> promise) noexcept {
-    try { if (Read(file) != expected) { promise.Resolve(false); return; } Write(file, contents); promise.Resolve(true); }
-    catch (std::exception const &error) { promise.Reject(error.what()); } catch (hresult_error const &error) { promise.Reject(to_string(error.message()).c_str()); }
-  }
-  REACT_METHOD(revealInFinder)
-  void revealInFinder(std::string file, React::ReactPromise<bool> promise) noexcept {
-    context.UIDispatcher().Post([file, promise] {
-      PIDLIST_ABSOLUTE item = nullptr;
-      try {
-        auto path = FilePath(file);
-        check_hresult(SHParseDisplayName(path.c_str(), nullptr, &item, 0, nullptr));
-        auto result = SHOpenFolderAndSelectItems(item, 0, nullptr, 0);
-        CoTaskMemFree(item); item = nullptr; check_hresult(result); promise.Resolve(true);
-      } catch (hresult_error const &error) { if (item) CoTaskMemFree(item); promise.Reject(React::ReactError{"E_REVEAL", to_string(error.message())}); }
-      catch (std::exception const &error) { if (item) CoTaskMemFree(item); promise.Reject(error.what()); }
-    });
-  }
 };
 }

package/vendor/node_modules/@legendapp/spark-file-system/RNDesktopFileSystem.podspec

@@ -14,4 +14,5 @@ Pod::Spec.new do |s|
   s.dependency "React-Core"
   s.dependency "ReactCodegen"
   s.dependency "RNDesktopApp"
+  s.osx.frameworks = "CoreServices"
 end

package/vendor/node_modules/@legendapp/spark-file-system/macos/RNDesktopFileSystem.mm

@@ -1,4 +1,7 @@
 #import "RNDesktopFileSystem.h"
+#import <RNDesktopApp/SparkBinaryJSI.h>
+#import <AppKit/AppKit.h>
+#import "SparkFileMutations.h"
 #import <RNDesktopApp/SparkDesktop.h>
 #import <fcntl.h>
 #import <unistd.h>
@@ -51,13 +54,15 @@ RCT_EXPORT_MODULE(NativeDesktopFileSystem)
 + (BOOL)requiresMainQueueSetup { return NO; }
 - (instancetype)init { if (self = [super init]) { _ioQueue = dispatch_queue_create("spark.files", DISPATCH_QUEUE_SERIAL); _files = [NSMutableDictionary new]; _watches = [NSMutableDictionary new]; _recursiveWatches = [NSMutableDictionary new]; } return self; }
 - (NSArray<NSString *> *)supportedEvents { return @[@"change"]; }
-- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { [self perform:method args:SparkArgs(json) binary:NO resolve:resolve reject:reject]; }
+- (void)binaryCall:(NSString *)method args:(NSString *)json bytes:(NSData *)bytes resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject { NSMutableDictionary *args = [SparkArgs(json) mutableCopy]; if (bytes) args[@"bytes"] = bytes; [self perform:method args:args binary:YES resolve:resolve reject:reject]; }
+- (void)perform:(NSString *)method args:(NSDictionary *)args binary:(BOOL)binary resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
   dispatch_async(self.ioQueue, ^{
-    NSDictionary *args = SparkArgs(json); NSFileManager *fm = NSFileManager.defaultManager;
+    NSFileManager *fm = NSFileManager.defaultManager;
     NSError *error = nil; id result = NSNull.null;
     if ([@[@"readChunk", @"writeChunk", @"flushFile", @"closeFile"] containsObject:method]) {
       NSString *identifier = args[@"id"]; SparkOpenFile *file = self.files[identifier];
-      if ([method isEqual:@"closeFile"]) { [self.files removeObjectForKey:identifier]; resolve(@"null"); return; }
+      if ([method isEqual:@"closeFile"]) { [self.files removeObjectForKey:identifier]; resolve(binary ? NSNull.null : @"null"); return; }
       if (!file) { reject(@"E_CLOSED", @"Unknown or closed file handle", nil); return; }
       if ([method isEqual:@"flushFile"]) { if (fsync(file.descriptor)) error = [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:nil]; }
       else {
@@ -69,11 +74,9 @@ RCT_EXPORT_MODULE(NativeDesktopFileSystem)
           NSMutableData *data = [NSMutableData dataWithLength:(NSUInteger)size]; ssize_t count;
           do { count = pread(file.descriptor, data.mutableBytes, data.length, (off_t)position); } while (count < 0 && errno == EINTR);
           if (count < 0) error = [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:nil];
-          else { data.length = count; result = [data base64EncodedStringWithOptions:0]; }
+          else { data.length = count; result = data; }
         } else {
-          NSString *base64 = args[@"base64"];
-          if (![base64 isKindOfClass:NSString.class] || base64.length > 1398104) { SparkInvalid(reject, @"Chunk exceeds 1 MiB"); return; }
-          NSData *data = [[NSData alloc] initWithBase64EncodedString:base64 options:0];
+          NSData *data = args[@"bytes"];
           if (!data || data.length > 1048576 || position + data.length > 9007199254740991.0) { SparkInvalid(reject, @"Invalid chunk"); return; }
           NSUInteger written = 0;
           while (written < data.length) {
@@ -122,29 +125,37 @@ RCT_EXPORT_MODULE(NativeDesktopFileSystem)
       } else if ([method isEqual:@"trash"]) { [fm trashItemAtURL:url resultingItemURL:nil error:&error]; }
       else if ([method isEqual:@"readText"]) result = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:&error];
       else if ([method isEqual:@"readBytes"]) {
-        NSData *data = [NSData dataWithContentsOfURL:url options:0 error:&error];
-        result = [data base64EncodedStringWithOptions:0];
+        NSMutableData *data = [NSMutableData dataWithContentsOfURL:url options:0 error:&error];
+        result = data;
+      }
+      else if ([method isEqual:@"reveal"]) {
+        if (![fm attributesOfItemAtPath:url.path error:&error]) { SparkReject(reject, error); return; }
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [[NSWorkspace sharedWorkspace] activateFileViewerSelectingURLs:@[url]];
+          resolve(binary ? NSNull.null : @"null");
+        });
+        return;
+      }
+      else if ([method isEqual:@"writeTextIfUnchanged"]) {
+        result = @(SparkWriteTextIfUnchanged(url, args[@"expected"], args[@"text"], &error));
       }
       else if ([method isEqual:@"writeText"]) [args[@"text"] writeToURL:url atomically:YES encoding:NSUTF8StringEncoding error:&error];
       else if ([method isEqual:@"writeBytes"]) {
-        NSData *data = [[NSData alloc] initWithBase64EncodedString:args[@"base64"] options:0];
-        if (!data) { SparkInvalid(reject, @"Invalid base64 data"); return; }
+        NSData *data = args[@"bytes"];
+        if (!data) { SparkInvalid(reject, @"Expected binary file data"); return; }
         [data writeToURL:url options:NSDataWritingAtomic error:&error];
       }
       else if ([method isEqual:@"mkdir"]) [fm createDirectoryAtURL:url withIntermediateDirectories:[args[@"recursive"] boolValue] attributes:nil error:&error];
       else if ([method isEqual:@"remove"]) {
-        BOOL directory = NO;
-        if (![fm fileExistsAtPath:url.path isDirectory:&directory]) { resolve(@"false"); return; }
-        if (directory && ![args[@"recursive"] boolValue] && [fm contentsOfDirectoryAtPath:url.path error:&error].count) {
-          reject(@"E_NOT_EMPTY", @"Directory is not empty; pass recursive: true", nil); return;
+        result = @(SparkRemoveFile(url, [args[@"recursive"] boolValue], &error));
+        if ([error.domain isEqual:NSPOSIXErrorDomain] && error.code == ENOTEMPTY) {
+          reject(@"E_NOT_EMPTY", @"Directory is not empty; pass recursive: true", error); return;
         }
-        if (!error) result = @([fm removeItemAtURL:url error:&error]);
       }
       else if ([method isEqual:@"copy"] || [method isEqual:@"move"]) {
         NSURL *to = FileURL(args[@"to"]);
         if (!to || !to.isFileURL || (to.host.length && ![to.host isEqual:@"localhost"])) { SparkInvalid(reject, @"Expected an absolute destination"); return; }
-        if ([method isEqual:@"copy"]) [fm copyItemAtURL:url toURL:to error:&error];
-        else [fm moveItemAtURL:url toURL:to error:&error];
+        SparkTransferPath(url, to, [method isEqual:@"copy"] ? SparkTransferCopy : SparkTransferMove, [args[@"overwrite"] boolValue], &error);
       }
       else if ([method isEqual:@"stat"]) {
         NSDictionary *attrs = [fm attributesOfItemAtPath:url.path error:&error];
@@ -177,7 +188,7 @@ RCT_EXPORT_MODULE(NativeDesktopFileSystem)
           if (!watch.stream) { reject(@"E_WATCH", @"Could not create directory watcher", nil); return; }
           FSEventStreamSetDispatchQueue(watch.stream, self.ioQueue);
           if (!FSEventStreamStart(watch.stream)) { [watch stop]; reject(@"E_WATCH", @"Could not start directory watcher", nil); return; }
-          self.recursiveWatches[watchID] = watch; resolve(@"null"); return;
+          self.recursiveWatches[watchID] = watch; resolve(binary ? NSNull.null : @"null"); return;
         }
         // Observe the parent so replacing a file atomically does not lose its watch.
         BOOL isDirectory = NO;
@@ -198,7 +209,7 @@ RCT_EXPORT_MODULE(NativeDesktopFileSystem)
       }
       else { SparkInvalid(reject, @"Unknown filesystem operation"); return; }
     }
-    if (error) SparkReject(reject, error); else resolve(SparkJSON(result));
+    if (error) SparkReject(reject, error); else resolve(binary ? result : SparkJSON(result));
   });
 }
 - (void)invalidate {
@@ -206,6 +217,6 @@ RCT_EXPORT_MODULE(NativeDesktopFileSystem)
   [super invalidate];
 }
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
-  return std::make_shared<facebook::react::NativeDesktopFileSystemSpecJSI>(params);
+  return std::make_shared<spark::binary::Module<facebook::react::NativeDesktopFileSystemSpecJSI>>(params);
 }
 @end

package/vendor/node_modules/@legendapp/spark-file-system/macos/SparkFileMutations.h

@@ -0,0 +1,24 @@
+#import <Foundation/Foundation.h>
+
+enum SparkTransferKind {
+  SparkTransferCopy,
+  SparkTransferMove,
+};
+
+// A false result with no error means conflict/absence respectively.
+BOOL SparkWriteTextIfUnchanged(NSURL *url, NSString *expected, NSString *text, NSError **error);
+BOOL SparkRemoveFile(NSURL *url, BOOL recursive, NSError **error);
+#if defined(SPARK_FILE_MUTATIONS_TESTING)
+enum SparkTransferTestFailure {
+  SparkFailStageCopy = 1 << 0,
+  SparkFailPublish = 1 << 1,
+  SparkFailRestoreDestination = 1 << 2,
+  SparkFailRestoreSource = 1 << 3,
+  SparkFailSourceRemoval = 1 << 4,
+  SparkFailBackupRemoval = 1 << 5,
+  SparkFailStageCleanup = 1 << 6,
+};
+void SparkSetTransferTestFailures(unsigned failures, BOOL forceCrossVolumeMove);
+#endif
+/** Copies or moves, replacing the destination only when overwrite is set. An existing destination otherwise conflicts with NSFileWriteFileExistsError, including a dangling link. Self-transfers and overlapping paths reject. Transfers stage beside the destination before publication; cross-volume moves copy then delete. A cross-volume source-cleanup failure can leave a partial source; source-cleanup and backup-cleanup errors report committed and retained paths. */
+BOOL SparkTransferPath(NSURL *from, NSURL *to, SparkTransferKind kind, BOOL overwrite, NSError **error);

package/vendor/node_modules/@legendapp/spark-file-system/macos/SparkFileMutations.mm

@@ -0,0 +1,215 @@
+#import "SparkFileMutations.h"
+#import <sys/stat.h>
+#import <errno.h>
+#import <unistd.h>
+#import <limits.h>
+#import <stdio.h>
+
+#if defined(SPARK_FILE_MUTATIONS_TESTING)
+static unsigned SparkTransferTestFailures;
+static BOOL SparkForceCrossVolumeMove;
+void SparkSetTransferTestFailures(unsigned failures, BOOL forceCrossVolumeMove) {
+  SparkTransferTestFailures = failures;
+  SparkForceCrossVolumeMove = forceCrossVolumeMove;
+}
+static BOOL SparkTakeTransferTestFailure(unsigned failure) {
+  if (!(SparkTransferTestFailures & failure)) return NO;
+  SparkTransferTestFailures &= ~failure;
+  errno = EIO;
+  return YES;
+}
+#define SPARK_TAKE_FAILURE(failure) SparkTakeTransferTestFailure(failure)
+#else
+#define SPARK_TAKE_FAILURE(failure) NO
+enum { SparkFailStageCopy = 0, SparkFailPublish = 0, SparkFailRestoreDestination = 0, SparkFailRestoreSource = 0,
+  SparkFailSourceRemoval = 0, SparkFailBackupRemoval = 0, SparkFailStageCleanup = 0 };
+#endif
+
+static int SparkPublishRename(NSString *from, NSString *to, unsigned failure) {
+#if !defined(SPARK_FILE_MUTATIONS_TESTING)
+  (void)failure;
+#endif
+  return SPARK_TAKE_FAILURE(failure) ? -1 : renamex_np(from.fileSystemRepresentation, to.fileSystemRepresentation, RENAME_EXCL);
+}
+
+static NSString *SparkSiblingPath(NSURL *url, NSString *label) {
+  return [url.URLByDeletingLastPathComponent.path stringByAppendingPathComponent:
+    [NSString stringWithFormat:@".spark-%@-%@", label, NSUUID.UUID.UUIDString]];
+}
+
+static NSString *SparkResolvedPath(NSURL *url) {
+  char resolved[PATH_MAX];
+  if (realpath(url.fileSystemRepresentation, resolved)) return @(resolved);
+  NSString *parent = url.URLByDeletingLastPathComponent.path;
+  if (realpath(parent.fileSystemRepresentation, resolved))
+    return [[@(resolved) stringByAppendingPathComponent:url.lastPathComponent] stringByStandardizingPath];
+  return url.URLByStandardizingPath.path;
+}
+
+static BOOL SparkPathContains(NSString *parent, NSString *child) {
+  if ([parent isEqualToString:child]) return YES;
+  NSString *prefix = [parent hasSuffix:@"/"] ? parent : [parent stringByAppendingString:@"/"];
+  return [child hasPrefix:prefix];
+}
+
+static BOOL SparkRejectUnsafeRelationship(NSURL *from, NSURL *to, NSError **error) {
+  struct stat sourceInfo, destinationInfo;
+  BOOL sourceExists = lstat(from.fileSystemRepresentation, &sourceInfo) == 0;
+  BOOL destinationExists = lstat(to.fileSystemRepresentation, &destinationInfo) == 0;
+  BOOL sameInode = sourceExists && destinationExists && sourceInfo.st_dev == destinationInfo.st_dev && sourceInfo.st_ino == destinationInfo.st_ino;
+  NSString *sourcePath = SparkResolvedPath(from), *destinationPath = SparkResolvedPath(to);
+  BOOL overlap = SparkPathContains(sourcePath, destinationPath) || SparkPathContains(destinationPath, sourcePath);
+  if (!sameInode && !overlap) return NO;
+  if (error) *error = [NSError errorWithDomain:NSCocoaErrorDomain code:NSFileWriteInvalidFileNameError userInfo:@{NSLocalizedDescriptionKey: @"Source and destination identify or contain one another"}];
+  return YES;
+}
+
+BOOL SparkWriteTextIfUnchanged(NSURL *url, NSString *expected, NSString *text, NSError **error) {
+  NSString *current = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:error];
+  if (!current || ![current isEqualToString:expected]) return NO;
+  return [text writeToURL:url atomically:YES encoding:NSUTF8StringEncoding error:error];
+}
+
+BOOL SparkTransferPath(NSURL *from, NSURL *to, SparkTransferKind kind, BOOL overwrite, NSError **error) {
+  NSFileManager *fm = NSFileManager.defaultManager;
+  if (SparkRejectUnsafeRelationship(from, to, error)) return NO;
+  struct stat existing;
+  BOOL destinationExists = NO;
+  if (lstat(to.fileSystemRepresentation, &existing) == 0) {
+    destinationExists = YES;
+    if (!overwrite) {
+      if (error) *error = [NSError errorWithDomain:NSCocoaErrorDomain code:NSFileWriteFileExistsError userInfo:nil];
+      return NO;
+    }
+  } else if (errno != ENOENT && errno != ENOTDIR) {
+    if (error) *error = [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:nil];
+    return NO;
+  }
+  NSString *stagePath = SparkSiblingPath(to, @"stage");
+  NSURL *stage = [NSURL fileURLWithPath:stagePath];
+  struct stat sourceStat, parentStat;
+  BOOL sameVolumeMove = kind == SparkTransferMove && lstat(from.fileSystemRepresentation, &sourceStat) == 0 &&
+    stat(to.URLByDeletingLastPathComponent.fileSystemRepresentation, &parentStat) == 0 && sourceStat.st_dev == parentStat.st_dev;
+#if defined(SPARK_FILE_MUTATIONS_TESTING)
+  if (SparkForceCrossVolumeMove) sameVolumeMove = NO;
+#endif
+  BOOL stagedByRename = NO;
+  if (sameVolumeMove) {
+    if (rename(from.fileSystemRepresentation, stage.fileSystemRepresentation) != 0) {
+      int code = errno;
+      if (error) *error = [NSError errorWithDomain:NSPOSIXErrorDomain code:code userInfo:nil];
+      return NO;
+    }
+    stagedByRename = YES;
+  } else {
+    NSError *copyError = nil;
+    BOOL staged = YES;
+    if (SPARK_TAKE_FAILURE(SparkFailStageCopy)) {
+#if defined(SPARK_FILE_MUTATIONS_TESTING)
+      [@"partial stage" writeToURL:stage atomically:YES encoding:NSUTF8StringEncoding error:nil];
+#endif
+      copyError = [NSError errorWithDomain:NSPOSIXErrorDomain code:EIO userInfo:nil];
+      staged = NO;
+    } else {
+      staged = [fm copyItemAtURL:from toURL:stage error:&copyError];
+    }
+    if (!staged) {
+      NSMutableDictionary *info = [copyError.userInfo mutableCopy] ?: [NSMutableDictionary dictionary];
+      struct stat partial;
+      if (lstat(stage.fileSystemRepresentation, &partial) == 0) {
+        NSError *cleanupError = nil;
+        BOOL failCleanup = SPARK_TAKE_FAILURE(SparkFailStageCleanup);
+        if (failCleanup) cleanupError = [NSError errorWithDomain:NSPOSIXErrorDomain code:EIO userInfo:nil];
+        if (failCleanup || ![fm removeItemAtURL:stage error:&cleanupError]) {
+          info[@"SparkRecoverableStagePath"] = stagePath;
+          info[NSLocalizedDescriptionKey] = [NSString stringWithFormat:@"Transfer staging failed and partial stage cleanup failed; recoverable stage: %@", stagePath];
+          if (cleanupError) info[@"SparkStageCleanupError"] = cleanupError;
+        }
+      }
+      if (error) *error = [NSError errorWithDomain:(copyError.domain ?: NSPOSIXErrorDomain)
+        code:(copyError ? copyError.code : EIO) userInfo:info];
+      return NO;
+    }
+  }
+  NSString *backupPath = nil;
+  if (destinationExists) {
+    backupPath = SparkSiblingPath(to, @"backup");
+    if (rename(to.fileSystemRepresentation, backupPath.fileSystemRepresentation) != 0) {
+      int code = errno;
+      int rollbackCode = 0;
+      if (stagedByRename && SparkPublishRename(stagePath, from.path, SparkFailRestoreSource) != 0) rollbackCode = errno;
+      else if (!stagedByRename && ![fm removeItemAtURL:stage error:nil]) rollbackCode = errno ?: EIO;
+      if (error) *error = [NSError errorWithDomain:NSPOSIXErrorDomain code:code userInfo:rollbackCode ? @{
+        NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Destination staging failed and source rollback failed (%d); recoverable source: %@", rollbackCode, stagePath],
+        NSUnderlyingErrorKey: [NSError errorWithDomain:NSPOSIXErrorDomain code:rollbackCode userInfo:nil],
+        @"SparkRecoverableStagePath": stagePath,
+      } : nil];
+      return NO;
+    }
+  }
+  int publishResult = SparkPublishRename(stagePath, to.path, SparkFailPublish);
+  if (publishResult != 0) {
+    int code = errno;
+    int rollbackCode = 0;
+    if (backupPath && SparkPublishRename(backupPath, to.path, SparkFailRestoreDestination) != 0) rollbackCode = errno;
+    if (stagedByRename && SparkPublishRename(stagePath, from.path, SparkFailRestoreSource) != 0) rollbackCode = errno;
+    if (!stagedByRename && ![fm removeItemAtURL:stage error:nil]) rollbackCode = errno ?: EIO;
+    if (error) *error = [NSError errorWithDomain:NSPOSIXErrorDomain code:code userInfo:rollbackCode ? @{
+      NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Transfer publication failed and rollback failed (%d); recoverable stage: %@; destination backup: %@", rollbackCode, stagePath, backupPath ?: @"none"],
+      NSUnderlyingErrorKey: [NSError errorWithDomain:NSPOSIXErrorDomain code:rollbackCode userInfo:nil],
+      @"SparkRecoverableStagePath": stagePath,
+      @"SparkRecoverableBackupPath": backupPath ?: @"",
+    } : nil];
+    return NO;
+  }
+  BOOL failSourceRemoval = SPARK_TAKE_FAILURE(SparkFailSourceRemoval);
+  if (kind == SparkTransferMove && !stagedByRename && (failSourceRemoval || ![fm removeItemAtURL:from error:error])) {
+    if (failSourceRemoval && error) *error = [NSError errorWithDomain:NSPOSIXErrorDomain code:EIO userInfo:nil];
+    if (error && *error) {
+      NSMutableDictionary *info = [(*error).userInfo mutableCopy] ?: [NSMutableDictionary dictionary];
+      info[NSLocalizedDescriptionKey] = [NSString stringWithFormat:@"Source cleanup failed after publishing %@; source may be partially removed%@", to.path, backupPath ? [NSString stringWithFormat:@"; previous destination is retained at %@", backupPath] : @""];
+      info[@"SparkPublishedDestinationPath"] = to.path;
+      if (backupPath) info[@"SparkPreviousDestinationBackupPath"] = backupPath;
+      *error = [NSError errorWithDomain:(*error).domain code:(*error).code userInfo:info];
+    }
+    return NO;
+  }
+  if (backupPath) {
+    NSError *cleanupError = nil;
+    BOOL failCleanup = SPARK_TAKE_FAILURE(SparkFailBackupRemoval);
+    BOOL removed = !failCleanup && [fm removeItemAtPath:backupPath error:&cleanupError];
+    if (!removed) {
+      if (failCleanup) cleanupError = [NSError errorWithDomain:NSPOSIXErrorDomain code:EIO userInfo:nil];
+      if (error) *error = [NSError errorWithDomain:(cleanupError.domain ?: NSPOSIXErrorDomain) code:cleanupError.code userInfo:@{
+        NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Transfer committed at %@, but previous destination cleanup failed; recoverable backup: %@", to.path, backupPath],
+        NSUnderlyingErrorKey: cleanupError ?: [NSError errorWithDomain:NSPOSIXErrorDomain code:EIO userInfo:nil],
+        @"SparkPublishedDestinationPath": to.path,
+        @"SparkRecoverableBackupPath": backupPath,
+      }];
+      return NO;
+    }
+  }
+  return YES;
+}
+
+BOOL SparkRemoveFile(NSURL *url, BOOL recursive, NSError **error) {
+  struct stat info;
+  if (lstat(url.fileSystemRepresentation, &info) != 0) {
+    int code = errno;
+    if (code == ENOENT || code == ENOTDIR) return NO;
+    if (error) *error = [NSError errorWithDomain:NSCocoaErrorDomain
+      code:(code == EACCES || code == EPERM) ? NSFileReadNoPermissionError : NSFileReadUnknownError
+      userInfo:@{NSUnderlyingErrorKey: [NSError errorWithDomain:NSPOSIXErrorDomain code:code userInfo:nil]}];
+    return NO;
+  }
+  NSFileManager *fm = NSFileManager.defaultManager;
+  if (S_ISDIR(info.st_mode) && !recursive) {
+    NSArray *children = [fm contentsOfDirectoryAtPath:url.path error:error];
+    if (!children) return NO;
+    if (children.count) {
+      if (error) *error = [NSError errorWithDomain:NSPOSIXErrorDomain code:ENOTEMPTY userInfo:nil];
+      return NO;
+    }
+  }
+  return [fm removeItemAtURL:url error:error];
+}

package/vendor/node_modules/@legendapp/spark-file-system/macos/file-scanner/RNFileScanner.h

@@ -0,0 +1,9 @@
+#import <React/RCTEventEmitter.h>
+#import <RNDesktopFileSystemSpec/RNDesktopFileSystemSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNFileScanner : RCTEventEmitter <NativeFileScannerSpec>
+@end
+
+NS_ASSUME_NONNULL_END

package/vendor/node_modules/@legendapp/spark-file-system/macos/file-scanner/RNFileScanner.mm

@@ -0,0 +1,82 @@
+#import "RNFileScanner.h"
+#import "RNFileScannerCore.h"
+#import <React/RCTBridgeModule.h>
+
+@interface SparkScanTask : NSObject
+@property (atomic) BOOL cancelled;
+@end
+@implementation SparkScanTask
+@end
+
+@implementation RNFileScanner {
+  BOOL _hasListeners;
+  BOOL _invalidated;
+  NSMutableDictionary<NSString *, SparkScanTask *> *_tasks;
+}
+RCT_EXPORT_MODULE(NativeFileScanner)
+- (instancetype)init { if (self = [super init]) _tasks = [NSMutableDictionary new]; return self; }
+- (NSArray<NSString *> *)supportedEvents { return @[@"onFileScanBatch", @"onFileScanProgress"]; }
+- (void)startObserving { @synchronized(self) { _hasListeners = YES; } }
+- (void)stopObserving { @synchronized(self) { _hasListeners = NO; } }
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeFileScannerSpecJSI>(params);
+}
+- (RNFileScannerOptions *)scanOptionsFromJSON:(NSString *)optionsJson
+{
+  id rawValue = RNFileScannerJSONObjectFromString(optionsJson);
+  NSDictionary *rawOptions = [rawValue isKindOfClass:NSDictionary.class] ? rawValue : @{};
+
+  RNFileScannerOptions *options = [RNFileScannerOptions new];
+  options.allowedExtensions = RNFileScannerExtensionsFromArray(rawOptions[@"allowedExtensions"], @[]);
+  options.batchSize = [rawOptions[@"batchSize"] unsignedIntegerValue] ?: 64;
+  options.includeHidden = [rawOptions[@"includeHidden"] boolValue];
+  options.includeStats = [rawOptions[@"includeStats"] boolValue];
+  options.skipLookup = RNFileScannerSkipLookupFromArray(rawOptions[@"skip"]);
+  return options;
+}
+
+
+- (BOOL)canEmitForTask:(SparkScanTask *)task {
+  @synchronized(self) { return _hasListeners && !_invalidated && !task.cancelled; }
+}
+
+- (void)scanFiles:(NSString *)identifier pathsJson:(NSString *)pathsJson optionsJson:(NSString *)optionsJson
+          resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  SparkScanTask *task = [SparkScanTask new];
+  @synchronized(self) {
+    if (_invalidated) { reject(@"E_CLOSED", @"Scanner has shut down", nil); return; }
+    if (_tasks[identifier]) { reject(@"E_BUSY", @"Duplicate scan ID", nil); return; }
+    _tasks[identifier] = task;
+  }
+  NSArray *paths = RNFileScannerJSONObjectFromString(pathsJson);
+  RNFileScannerOptions *options = [self scanOptionsFromJSON:optionsJson];
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSDictionary *result = RNFileScannerRun(paths, options, nil,
+      ^(NSArray<NSDictionary *> *items, NSUInteger rootIndex, NSUInteger completedRoots, NSUInteger totalRoots) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+          if ([self canEmitForTask:task]) [self sendEventWithName:@"onFileScanBatch" body:@{
+            @"id": identifier, @"files": items, @"rootIndex": @(rootIndex), @"completedRoots": @(completedRoots), @"totalRoots": @(totalRoots)}];
+        });
+      },
+      ^(NSUInteger rootIndex, NSUInteger completedRoots, NSUInteger totalRoots) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+          if ([self canEmitForTask:task]) [self sendEventWithName:@"onFileScanProgress" body:@{
+            @"id": identifier, @"rootIndex": @(rootIndex), @"completedRoots": @(completedRoots), @"totalRoots": @(totalRoots)}];
+        });
+      }, ^BOOL { return task.cancelled; });
+    dispatch_async(dispatch_get_main_queue(), ^{
+      @synchronized(self) { [self->_tasks removeObjectForKey:identifier]; }
+      if (task.cancelled) reject(@"E_ABORTED", @"File scan cancelled", nil);
+      else resolve(RNFileScannerJSONString(result));
+    });
+  });
+}
+- (void)cancelScan:(NSString *)identifier resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  @synchronized(self) { _tasks[identifier].cancelled = YES; }
+  resolve(nil);
+}
+- (void)invalidate {
+  @synchronized(self) { _invalidated = YES; for (SparkScanTask *task in _tasks.allValues) task.cancelled = YES; }
+  [super invalidate];
+}
+@end

package/vendor/node_modules/@legendapp/spark-file-system/macos/file-scanner/RNFileScannerCore.h

@@ -0,0 +1,47 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RNFileScannerOptions : NSObject
+@property (nonatomic, copy) NSSet<NSString *> *allowedExtensions;
+@property (nonatomic, assign) NSUInteger batchSize;
+@property (nonatomic, assign) BOOL includeHidden;
+@property (nonatomic, assign) BOOL includeStats;
+@property (nonatomic, copy) NSDictionary<NSNumber *, NSSet<NSString *> *> *skipLookup;
+@end
+
+typedef NSDictionary *_Nullable (^RNFileScannerMapFileBlock)(NSURL *fileURL,
+                                                             NSString *rootPath,
+                                                             NSUInteger rootIndex,
+                                                             NSString *relativePath,
+                                                             BOOL skipped);
+typedef void (^RNFileScannerEmitBatchBlock)(NSArray<NSDictionary *> *items,
+                                            NSUInteger rootIndex,
+                                            NSUInteger completedRoots,
+                                            NSUInteger totalRoots);
+typedef void (^RNFileScannerProgressBlock)(NSUInteger rootIndex,
+                                           NSUInteger completedRoots,
+                                           NSUInteger totalRoots);
+
+NSString *RNFileScannerNormalizePath(NSString *path);
+NSString *RNFileScannerRelativePath(NSString *fullPath, NSString *rootPath);
+NSArray<NSString *> *RNFileScannerNormalizeRoots(NSArray<NSString *> *paths);
+NSSet<NSString *> *RNFileScannerExtensionsFromArray(NSArray<NSString *> *_Nullable extensions,
+                                                   NSArray<NSString *> *defaultExtensions);
+NSDictionary<NSNumber *, NSSet<NSString *> *> *RNFileScannerSkipLookupFromArray(NSArray *_Nullable skipEntries);
+NSDictionary *RNFileScannerDefaultFileItem(NSURL *fileURL,
+                                           NSString *rootPath,
+                                           NSUInteger rootIndex,
+                                           NSString *relativePath,
+                                           BOOL skipped,
+                                           BOOL includeStats);
+NSDictionary *RNFileScannerRun(NSArray<NSString *> *paths,
+                               RNFileScannerOptions *options,
+                               RNFileScannerMapFileBlock _Nullable mapFile,
+                               RNFileScannerEmitBatchBlock _Nullable emitBatch,
+                               RNFileScannerProgressBlock _Nullable emitProgress,
+                               BOOL (^ _Nullable isCancelled)(void));
+NSString *RNFileScannerJSONString(id object);
+id RNFileScannerJSONObjectFromString(NSString *json);
+
+NS_ASSUME_NONNULL_END