@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-context-menu/macos/RNContextMenu.mm

@@ -0,0 +1,160 @@
+#import "RNContextMenu.h"
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTUtils.h>
+#import <TargetConditionals.h>
+
+#if TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+#endif
+
+@interface RNContextMenu ()
+#if TARGET_OS_OSX
+<NSMenuDelegate>
+#endif
+@property (nonatomic, copy) RCTPromiseResolveBlock pendingResolve;
+@property (nonatomic, strong) id activeMenu;
+@property (nonatomic, assign) BOOL didResolveSelection;
+@end
+
+@implementation RNContextMenu
+
+RCT_EXPORT_MODULE(NativeContextMenu)
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeContextMenuSpecJSI>(params);
+}
+
+- (id)parseJSON:(NSString *)json fallback:(id)fallback
+{
+  NSData *data = [json dataUsingEncoding:NSUTF8StringEncoding];
+  if (!data) {
+    return fallback;
+  }
+
+  id value = [NSJSONSerialization JSONObjectWithData:data options:0 error:nil];
+  return value ?: fallback;
+}
+
+- (void)showMenu:(NSString *)itemsJson
+    locationJson:(NSString *)locationJson
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject
+{
+#if TARGET_OS_OSX
+  RCTExecuteOnMainQueue(^{
+    NSArray *items = [self parseJSON:itemsJson fallback:@[]];
+    NSDictionary *location = [self parseJSON:locationJson fallback:@{}];
+    if (![items isKindOfClass:[NSArray class]] || items.count == 0) {
+      resolve(@"");
+      return;
+    }
+
+    if (self.pendingResolve) {
+      reject(@"E_BUSY", @"A context menu is already open", nil);
+      return;
+    }
+
+    self.pendingResolve = resolve;
+    self.didResolveSelection = NO;
+
+    NSMenu *menu = [[NSMenu alloc] initWithTitle:@"ContextMenu"];
+    menu.autoenablesItems = NO;
+    menu.delegate = self;
+
+    for (NSDictionary *itemConfig in items) {
+      if (![itemConfig isKindOfClass:[NSDictionary class]]) {
+        continue;
+      }
+
+      if ([itemConfig[@"separator"] boolValue]) { [menu addItem:NSMenuItem.separatorItem]; continue; }
+      NSString *title = [itemConfig[@"title"] isKindOfClass:[NSString class]] ? itemConfig[@"title"] : @"";
+      NSString *itemId = [itemConfig[@"id"] isKindOfClass:[NSString class]] ? itemConfig[@"id"] : title;
+      BOOL enabled = itemConfig[@"enabled"] ? [itemConfig[@"enabled"] boolValue] : YES;
+      NSMenuItem *item = [[NSMenuItem alloc] initWithTitle:title action:@selector(handleMenuItem:) keyEquivalent:@""];
+      item.target = self;
+      item.representedObject = itemId ?: @"";
+      item.enabled = enabled;
+      item.state = [itemConfig[@"checked"] boolValue] ? NSControlStateValueOn : NSControlStateValueOff;
+      [menu addItem:item];
+    }
+
+    if (menu.numberOfItems == 0) {
+      self.pendingResolve(@"");
+      self.pendingResolve = nil;
+      return;
+    }
+
+    NSWindow *window = NSApp.keyWindow ?: NSApp.mainWindow;
+    NSView *targetView = window.contentView;
+    if (!targetView) {
+      self.pendingResolve(@"");
+      self.pendingResolve = nil;
+      return;
+    }
+
+    double x = [location[@"x"] isKindOfClass:[NSNumber class]] ? [location[@"x"] doubleValue] : 0;
+    double y = [location[@"y"] isKindOfClass:[NSNumber class]] ? [location[@"y"] doubleValue] : 0;
+    NSPoint point = NSMakePoint(x, y);
+    if (!targetView.isFlipped) {
+      point.y = NSHeight(targetView.bounds) - point.y;
+    }
+
+    self.activeMenu = menu;
+    // Tracking runs a nested event loop. Enter from the run loop, rather
+    // than holding the main dispatch queue needed by other native calls.
+    [NSRunLoop.mainRunLoop performBlock:^{
+      if (self.activeMenu == menu) [menu popUpMenuPositioningItem:nil atLocation:point inView:targetView];
+    }];
+  });
+#else
+  resolve(@"");
+#endif
+}
+
+#if TARGET_OS_OSX
+- (void)invalidate
+{
+  RCTExecuteOnMainQueue(^{
+    ((NSMenu *)self.activeMenu).delegate = nil;
+    [(NSMenu *)self.activeMenu cancelTracking];
+    if (self.pendingResolve) self.pendingResolve(@"");
+    self.pendingResolve = nil; self.activeMenu = nil;
+  });
+}
+
+- (void)handleMenuItem:(NSMenuItem *)sender
+{
+  if (!self.pendingResolve) {
+    return;
+  }
+
+  self.didResolveSelection = YES;
+  NSString *itemId = [sender.representedObject isKindOfClass:[NSString class]] ? sender.representedObject : @"";
+  self.pendingResolve(itemId ?: @"");
+  self.pendingResolve = nil;
+  ((NSMenu *)self.activeMenu).delegate = nil;
+  self.activeMenu = nil;
+}
+
+- (void)menuDidClose:(NSMenu *)menu
+{
+  if (menu != self.activeMenu) {
+    return;
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (!self.didResolveSelection && self.pendingResolve) {
+      self.pendingResolve(@"");
+    }
+    self.pendingResolve = nil;
+    ((NSMenu *)self.activeMenu).delegate = nil;
+    self.activeMenu = nil;
+    self.didResolveSelection = NO;
+  });
+}
+#endif
+
+@end

package/vendor/node_modules/@legendapp/spark-context-menu/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@legendapp/spark-context-menu",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "main": "src/index.ts",
+  "react-native": "src/index.ts",
+  "files": [
+    "src",
+    "macos",
+    "*.podspec",
+    "windows",
+    "react-native.config.js"
+  ],
+  "peerDependencies": {
+    "react": "19.1.4",
+    "react-native": "0.81.6"
+  },
+  "codegenConfig": {
+    "name": "RNContextMenuSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "ios": {
+      "modulesProvider": {
+        "NativeContextMenu": "RNContextMenu"
+      }
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "nativeModules": [
+      "NativeContextMenu"
+    ],
+    "pod": "RNContextMenu",
+    "platforms": [
+      "macos",
+      "windows"
+    ],
+    "requires": [
+      "@legendapp/spark-desktop-app"
+    ]
+  },
+  "dependencies": {
+    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+  },
+  "private": true
+}

package/vendor/node_modules/@legendapp/spark-context-menu/react-native.config.js

@@ -0,0 +1,6 @@
+// Expo Desktop currently invokes the Apple autolinker with --platform ios.
+// Its generated Podfile identifies macOS explicitly; ordinary iOS apps use Expo backends.
+module.exports = { dependency: { platforms: {
+  ios: process.env.SPARK_DESKTOP_AUTOLINK === "macos" ? {} : null,
+  android: null,
+} } };

package/vendor/node_modules/@legendapp/spark-context-menu/src/NativeContextMenu.ts

@@ -0,0 +1,8 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+
+export interface Spec extends TurboModule {
+  showMenu(itemsJson: string, locationJson: string): Promise<string>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>("NativeContextMenu");

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

@@ -0,0 +1,29 @@
+import { Platform } from "react-native";
+import NativeContextMenu from "./NativeContextMenu";
+
+export type ContextMenuItem = {
+  id: string;
+  title: string;
+  enabled?: boolean;
+  checked?: boolean;
+  separator?: boolean;
+};
+
+export type ContextMenuLocation = {
+  x: number;
+  y: number;
+};
+
+export async function showContextMenu(items: ContextMenuItem[], location: ContextMenuLocation) {
+  if (Platform.OS !== "macos" && Platform.OS !== "windows") {
+    return null;
+  }
+
+  if (!Number.isFinite(location.x) || !Number.isFinite(location.y)) throw new Error("Menu location must be finite");
+  const ids = items.filter(item => !item.separator).map(item => item.id);
+  if (new Set(ids).size !== ids.length) throw new Error("Context menu ids must be unique");
+  const result = await NativeContextMenu.showMenu(JSON.stringify(items), JSON.stringify(location));
+  return result.length > 0 ? result : null;
+}
+
+export { default as NativeContextMenu } from "./NativeContextMenu";

package/vendor/node_modules/@legendapp/spark-context-menu/windows/ExperimentalFeatures.props

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <PropertyGroup Label="Microsoft.ReactNative Experimental Features">
+    <!--
+      Required for building a New Architecture project.
+
+      Library projects can change this value to test against Old and New
+      Architectures when building the library project's local sln file.
+
+      Otherwise this value will be decided by the consuming RNW app.
+
+      See https://microsoft.github.io/react-native-windows/docs/new-architecture
+    -->
+    <RnwNewArch>true</RnwNewArch>
+
+    <!--
+      Changes compilation to assume use of Microsoft.ReactNative NuGet packages
+      instead of building the framework from source. Defaults to true.
+
+      This is set during library project creation and is used when building
+      the library project's local sln file.
+
+      Otherwise this value will be decided by the consuming RNW app.
+
+      See https://microsoft.github.io/react-native-windows/docs/nuget
+    -->
+    <UseExperimentalNuget>true</UseExperimentalNuget>
+
+    <ReactExperimentalFeaturesSet>true</ReactExperimentalFeaturesSet>
+  </PropertyGroup>
+
+</Project>

package/vendor/node_modules/@legendapp/spark-context-menu/windows/LICENSE

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+
+Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+
+Portions derived from React Native:
+
+Copyright (c) 2015-present, Facebook, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/node_modules/@legendapp/spark-context-menu/windows/SparkContextMenu/ReactPackageProvider.cpp

@@ -0,0 +1,20 @@
+#include "pch.h"
+
+#include "ReactPackageProvider.h"
+#if __has_include("ReactPackageProvider.g.cpp")
+#include "ReactPackageProvider.g.cpp"
+#endif
+
+#include "SparkContextMenu.h"
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::SparkContextMenu::implementation
+{
+
+void ReactPackageProvider::CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept
+{
+  AddAttributedModules(packageBuilder, true);
+}
+
+} // namespace winrt::SparkContextMenu::implementation

package/vendor/node_modules/@legendapp/spark-context-menu/windows/SparkContextMenu/ReactPackageProvider.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "ReactPackageProvider.g.h"
+
+using namespace winrt::Microsoft::ReactNative;
+
+namespace winrt::SparkContextMenu::implementation
+{
+
+struct ReactPackageProvider : ReactPackageProviderT<ReactPackageProvider>
+{
+  ReactPackageProvider() = default;
+
+  void CreatePackage(IReactPackageBuilder const &packageBuilder) noexcept;
+};
+
+} // namespace winrt::SparkContextMenu::implementation
+
+namespace winrt::SparkContextMenu::factory_implementation
+{
+
+struct ReactPackageProvider : ReactPackageProviderT<ReactPackageProvider, implementation::ReactPackageProvider> {};
+
+} // namespace winrt::SparkContextMenu::factory_implementation

package/vendor/node_modules/@legendapp/spark-context-menu/windows/SparkContextMenu/ReactPackageProvider.idl

@@ -0,0 +1,9 @@
+namespace SparkContextMenu
+{
+  [webhosthidden]
+  [default_interface]
+  runtimeclass ReactPackageProvider : Microsoft.ReactNative.IReactPackageProvider
+  {
+    ReactPackageProvider();
+  };
+}

package/vendor/node_modules/@legendapp/spark-context-menu/windows/SparkContextMenu/SparkContextMenu.cpp

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

package/vendor/node_modules/@legendapp/spark-context-menu/windows/SparkContextMenu/SparkContextMenu.def

@@ -0,0 +1,3 @@
+EXPORTS
+DllCanUnloadNow = WINRT_CanUnloadNow                    PRIVATE
+DllGetActivationFactory = WINRT_GetActivationFactory    PRIVATE

package/vendor/node_modules/@legendapp/spark-context-menu/windows/SparkContextMenu/SparkContextMenu.h

@@ -0,0 +1,112 @@
+#pragma once
+#include "NativeModules.h"
+#include <commctrl.h>
+#include <winrt/Windows.Data.Json.h>
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <vector>
+#include <set>
+#include <cmath>
+#include <climits>
+#pragma comment(lib, "Comctl32.lib")
+namespace winrt::SparkContextMenu {
+namespace React = Microsoft::ReactNative;
+namespace Json = Windows::Data::Json;
+// Match the framework's own top-level windows, never another process's HWND.
+inline HWND Parent(std::wstring const &id, bool explicitId) {
+  HWND active = GetActiveWindow();
+  if (!explicitId && active && GetPropW(active, L"Spark.ReactWindow")) return active;
+  struct Search { std::wstring property; HWND found = nullptr; } search{L"Spark.Window." + (explicitId ? id : L"main")};
+  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));
+  return search.found;
+}
+// Modal Win32 APIs pump a nested loop. Start outside the RN dispatcher callback
+// so React can still deliver another call (which must reject E_BUSY).
+inline LRESULT CALLBACK TaskProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
+  if (message == WM_NCCREATE) {
+    auto pending = reinterpret_cast<std::unique_ptr<std::function<void()>> *>(reinterpret_cast<CREATESTRUCTW *>(lparam)->lpCreateParams);
+    SetWindowLongPtrW(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(pending->release()));
+  }
+  if (message == WM_APP + 1) {
+    auto raw = reinterpret_cast<std::function<void()> *>(GetWindowLongPtrW(hwnd, GWLP_USERDATA));
+    SetWindowLongPtrW(hwnd, GWLP_USERDATA, 0); std::unique_ptr<std::function<void()>> action(raw); DestroyWindow(hwnd);
+    if (action) (*action)(); return 0;
+  }
+  if (message == WM_NCDESTROY) {
+    delete reinterpret_cast<std::function<void()> *>(GetWindowLongPtrW(hwnd, GWLP_USERDATA)); SetWindowLongPtrW(hwnd, GWLP_USERDATA, 0);
+  }
+  return DefWindowProcW(hwnd, message, wparam, lparam);
+}
+inline void Schedule(React::ReactContext context, std::function<void()> action, std::function<void()> failure) {
+  context.UIDispatcher().Post([action = std::move(action), failure = std::move(failure)]() {
+    const wchar_t *name = L"SparkContextMenuTask";
+    WNDCLASSW cls{}; cls.lpfnWndProc = TaskProc; cls.hInstance = GetModuleHandleW(nullptr); cls.lpszClassName = name;
+    if (!RegisterClassW(&cls) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS) { failure(); return; }
+    auto pending = std::make_unique<std::function<void()>>(action);
+    // Ownership passes on WM_NCCREATE. This class always accepts creation.
+    auto hwnd = CreateWindowExW(0, name, L"", 0, 0, 0, 0, 0, HWND_MESSAGE, nullptr, cls.hInstance, &pending);
+    if (!hwnd) { failure(); return; }
+    if (!PostMessageW(hwnd, WM_APP + 1, 0, 0)) { DestroyWindow(hwnd); failure(); }
+  });
+}
+struct MenuState {
+  std::atomic<bool> busy{false}, stopped{false};
+  std::atomic<HWND> owner{nullptr};
+};
+struct MenuHandle { HMENU value = CreatePopupMenu(); ~MenuHandle() { if (value) DestroyMenu(value); } };
+REACT_MODULE(SparkContextMenu, L"NativeContextMenu")
+struct SparkContextMenu {
+  React::ReactContext context;
+  std::shared_ptr<MenuState> state = std::make_shared<MenuState>();
+  REACT_INIT(Initialize) void Initialize(React::ReactContext const &value) noexcept { context = value; }
+  ~SparkContextMenu() {
+    state->stopped = true;
+    if (auto owner = state->owner.load()) PostMessageW(owner, WM_CANCELMODE, 0, 0);
+  }
+  REACT_METHOD(showMenu) void showMenu(std::string encoded, std::string location, React::ReactPromise<std::string> promise) noexcept {
+    if (state->busy.exchange(true)) { promise.Reject(React::ReactError{"E_BUSY", "A context menu is already open"}); return; }
+    auto current = state;
+    Schedule(context, [current, encoded, location, promise] {
+      try {
+        if (current->stopped) { current->busy = false; promise.Resolve(""); return; }
+        auto items = Json::JsonArray::Parse(to_hstring(encoded));
+        auto position = Json::JsonObject::Parse(to_hstring(location));
+        auto owner = Parent(L"", false);
+        if (!owner || items.Size() == 0) { current->busy = false; promise.Resolve(""); return; }
+        if (!IsWindowEnabled(owner)) { current->busy = false; promise.Reject(React::ReactError{"E_BUSY", "Menu parent has a modal operation"}); return; }
+        const double x = position.GetNamedNumber(L"x"), y = position.GetNamedNumber(L"y");
+        const double scale = static_cast<double>(GetDpiForWindow(owner)) / 96.0;
+        if (!std::isfinite(x) || !std::isfinite(y) || std::abs(x * scale) > INT_MAX / 2 || std::abs(y * scale) > INT_MAX / 2) throw hresult_invalid_argument(L"Menu location must be finite and within screen coordinates");
+        POINT point{static_cast<LONG>(std::lround(x * scale)), static_cast<LONG>(std::lround(y * scale))};
+        if (!ClientToScreen(owner, &point)) throw_last_error();
+        MenuHandle menu; if (!menu.value) throw_last_error();
+        std::vector<std::string> ids; std::set<std::string> unique;
+        for (auto const &value : items) {
+          auto item = value.GetObject();
+          if (item.GetNamedBoolean(L"separator", false)) { if (!AppendMenuW(menu.value, MF_SEPARATOR, 0, nullptr)) throw_last_error(); continue; }
+          auto id = to_string(item.GetNamedString(L"id"));
+          if (!unique.insert(id).second) throw hresult_invalid_argument(L"Context menu ids must be unique");
+          ids.push_back(id); std::wstring label;
+          for (auto c : std::wstring(item.GetNamedString(L"title"))) { label += c; if (c == L'&') label += L'&'; }
+          UINT flags = MF_STRING;
+          if (!item.GetNamedBoolean(L"enabled", true)) flags |= MF_GRAYED;
+          if (item.GetNamedBoolean(L"checked", false)) flags |= MF_CHECKED;
+          if (!AppendMenuW(menu.value, flags, static_cast<UINT_PTR>(ids.size()), label.c_str())) throw_last_error();
+        }
+        current->owner = owner;
+        SetLastError(ERROR_SUCCESS);
+        const auto selected = TrackPopupMenuEx(menu.value, TPM_RETURNCMD | TPM_NONOTIFY | TPM_RIGHTBUTTON, point.x, point.y, owner, nullptr);
+        const auto error = GetLastError(); current->owner = nullptr; current->busy = false;
+        if (!selected && error != ERROR_SUCCESS) throw hresult_error(HRESULT_FROM_WIN32(error));
+        promise.Resolve(!current->stopped && selected > 0 && static_cast<size_t>(selected) <= ids.size() ? ids[selected - 1] : "");
+      } catch (hresult_error const &error) { current->owner = nullptr; current->busy = false; promise.Reject(React::ReactError{error.code() == E_INVALIDARG ? "E_INVALID_ARGUMENT" : "E_MENU", to_string(error.message())}); }
+      catch (std::exception const &error) { current->owner = nullptr; current->busy = false; promise.Reject(React::ReactError{"E_MENU", error.what()}); }
+    }, [current, promise] { current->busy = false; promise.Reject(React::ReactError{"E_MENU", "Could not schedule native menu"}); });
+  }
+};
+}

package/vendor/node_modules/@legendapp/spark-context-menu/windows/SparkContextMenu/SparkContextMenu.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>{9C2F5D53-F74C-47EE-9FA3-B9103CC871B5}</ProjectGuid>
+    <ProjectName>SparkContextMenu</ProjectName>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>SparkContextMenu</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>SparkContextMenu.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="SparkContextMenu.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="SparkContextMenu.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="SparkContextMenu.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>