@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-native-menu/src/api.ts

@@ -0,0 +1,128 @@
+import { NativeEventEmitter, Platform } from "react-native";
+import { useEffect } from "react";
+import NativeMenu from "./NativeMenu";
+import { composeWindowsMenus, patchWindowsMenus } from "./windows-menus";
+
+export type NativeMenuShortcut = {
+  key: string;
+  modifiers?: number;
+};
+
+export type NativeMenuItemPlacement = {
+  before?: string;
+  after?: string;
+};
+
+export const commandModifier = 1 << 20;
+export const optionModifier = 1 << 19;
+export const shiftModifier = 1 << 17;
+export const settingsTargetTitles = ["Settings...", "Settings…", "Preferences...", "Preferences…"];
+export const openTargetTitles = ["Open", "Open...", "Open…"];
+export const saveTargetTitles = ["Save", "Save...", "Save…"];
+export const saveAsTargetTitles = ["Save As", "Save As...", "Save As…"];
+
+export type NativeMenuItem = {
+  id: string;
+  title?: string;
+  targetTitle?: string;
+  targetTitles?: string[];
+  /** Nested native system-menu paths are macOS-only. Windows accepts one item title. */
+  targetPath?: string[];
+  enabled?: boolean;
+  checked?: boolean;
+  hidden?: boolean;
+  placement?: NativeMenuItemPlacement;
+  separator?: boolean;
+  shortcut?: NativeMenuShortcut | null;
+  payload?: Record<string, unknown>;
+};
+
+export type NativeMenuConfig = {
+  id: string;
+  title: string;
+  systemMenu?: "app";
+  placement?: {
+    before?: string;
+    after?: string;
+  };
+  items: NativeMenuItem[];
+};
+
+export type NativeMenuItemPatch = Omit<Partial<NativeMenuItem>, "separator"> & {
+  id: string;
+};
+
+export type NativeMenuAction = {
+  ownerId: string;
+  menuId: string;
+  itemId: string;
+  payload?: Record<string, unknown>;
+};
+
+export type NativeMenuActionHandlers = Record<string, (action: NativeMenuAction) => void>;
+
+export type UseNativeMenuOptions = {
+  handlers?: NativeMenuActionHandlers;
+  menus: NativeMenuConfig[];
+  onAction?: (action: NativeMenuAction) => void;
+  ownerId: string;
+};
+
+const windowsOwners = new Map<string, NativeMenuConfig[]>();
+function publishWindowsMenus(next: Map<string, NativeMenuConfig[]>) {
+  // Composition can reject unsupported targets. Preserve the last good owners
+  // and native menu when a proposed contribution is invalid.
+  const composed = composeWindowsMenus(next);
+  NativeMenu.configureMenus("spark.windows.menus", JSON.stringify(composed));
+  windowsOwners.clear(); for (const [owner, menus] of next) windowsOwners.set(owner, menus);
+}
+export function configureMenus(ownerId: string, menus: NativeMenuConfig[]) {
+  if (Platform.OS === "windows") { const next = new Map(windowsOwners); next.set(ownerId, JSON.parse(JSON.stringify(menus))); publishWindowsMenus(next); }
+  else if (Platform.OS === "macos") NativeMenu.configureMenus(ownerId, JSON.stringify(menus));
+}
+export function updateMenuItems(ownerId: string, patches: NativeMenuItemPatch[]) {
+  if (Platform.OS === "windows") {
+    const menus = windowsOwners.get(ownerId); if (menus) { const next = new Map(windowsOwners); next.set(ownerId, patchWindowsMenus(menus, patches)); publishWindowsMenus(next); }
+  } else if (Platform.OS === "macos") NativeMenu.updateMenuItems(ownerId, JSON.stringify(patches));
+}
+export function clearMenus(ownerId: string) {
+  if (Platform.OS === "windows") { const next = new Map(windowsOwners); next.delete(ownerId); publishWindowsMenus(next); }
+  else if (Platform.OS === "macos") NativeMenu.clearMenus(ownerId);
+}
+export function clearAllMenus() {
+  if (Platform.OS === "windows") { publishWindowsMenus(new Map()); }
+  else if (Platform.OS === "macos") NativeMenu.clearAllMenus();
+}
+
+export function addNativeMenuActionListener(listener: (action: NativeMenuAction) => void) {
+  if ((Platform.OS !== "macos" && Platform.OS !== "windows")) {
+    return { remove() {} };
+  }
+
+  const emitter = new NativeEventEmitter(NativeMenu as never);
+  return emitter.addListener("NativeMenuAction", listener);
+}
+
+export function useNativeMenu({ handlers, menus, onAction, ownerId }: UseNativeMenuOptions) {
+  useEffect(() => {
+    configureMenus(ownerId, menus);
+
+    const subscription = addNativeMenuActionListener((action) => {
+      if (action.ownerId === ownerId) {
+        const handler = handlers?.[action.itemId];
+        if (handler) {
+          handler(action);
+        } else {
+          onAction?.(action);
+        }
+      }
+    });
+
+    return () => {
+      subscription.remove();
+      clearMenus(ownerId);
+    };
+  }, [handlers, menus, onAction, ownerId]);
+}
+
+export { default as NativeMenu } from "./NativeMenu";

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

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

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

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

package/vendor/node_modules/@legendapp/spark-native-menu/src/windows-menus.ts

@@ -0,0 +1,43 @@
+import type { NativeMenuConfig, NativeMenuItem, NativeMenuItemPatch } from "./api";
+type Item = NativeMenuItem & { _sparkOwner: string; _sparkMenu: string };
+type Menu = Omit<NativeMenuConfig, "items"> & { items: Item[] };
+const titleKey = (title = "") => title.replaceAll("…", "...").trim().toLowerCase();
+function insertion<T extends { title?: string }>(items: T[], placement?: { before?: string; after?: string }) {
+  for (const position of ["before", "after"] as const) {
+    const title = placement?.[position];
+    if (title) { const index = items.findIndex(item => titleKey(item.title) === titleKey(title)); if (index >= 0) return index + (position === "after" ? 1 : 0); }
+  }
+  return items.length;
+}
+/** Recompute owners' contributions so removing a binding restores the original item. */
+export type MenuDiagnostic = { code: "E_MENU_TARGET_NOT_FOUND"; ownerId: string; menuId: string; itemId: string; targets: string[] };
+export function composeWindowsMenus(owners: ReadonlyMap<string, NativeMenuConfig[]>, diagnose: (diagnostic: MenuDiagnostic) => void = diagnostic => console.warn("Windows menu target not found", diagnostic)): Menu[] {
+  const result: Menu[] = [];
+  for (const [owner, configs] of owners) for (const config of configs) {
+    let menu = result.find(menu => config.systemMenu === "app" ? menu.systemMenu === "app" : menu.title === config.title);
+    if (!menu) {
+      menu = { ...config, items: [] };
+      result.splice(config.systemMenu === "app" ? 0 : insertion(result, config.placement), 0, menu);
+    }
+    for (const input of config.items) {
+      // Public menu contributions are flat on Windows; AppKit system submenus
+      // have no counterpart. Reject before publishing rather than dropping them.
+      if ((input.targetPath?.length ?? 0) > 1) throw Object.assign(new Error(`Windows menu ${config.id}/${input.id} does not support nested targetPath: ${input.targetPath!.join(" > ")}`), { code: "E_MENU_TARGET_UNSUPPORTED" });
+      const candidates = input.targetPath?.length ? input.targetPath : [input.targetTitle, ...(input.targetTitles ?? [])].filter((title): title is string => !!title);
+      const targets = !!(input.targetTitle || input.targetTitles?.length || input.targetPath?.length);
+      const target = candidates.map(title => menu.items.find(item => titleKey(item.title) === titleKey(title))).find(Boolean);
+      if (targets && !target) { diagnose({ code: "E_MENU_TARGET_NOT_FOUND", ownerId: owner, menuId: config.id, itemId: input.id, targets: candidates }); continue; }
+      const identity = input.targetPath?.length && target ? { _sparkOwner: target._sparkOwner, _sparkMenu: target._sparkMenu, id: target.id, payload: target.payload } : { _sparkOwner: owner, _sparkMenu: config.id, id: input.id };
+      const item: Item = { ...target, ...input, ...identity };
+      if (target) {
+        const index = menu.items.indexOf(target);
+        menu.items.splice(index, 1);
+        menu.items.splice(input.placement ? insertion(menu.items, input.placement) : index, 0, item);
+      } else menu.items.splice(insertion(menu.items, input.placement), 0, item);
+    }
+  }
+  return result;
+}
+export function patchWindowsMenus(menus: NativeMenuConfig[], patches: NativeMenuItemPatch[]): NativeMenuConfig[] {
+  return menus.map(menu => ({ ...menu, items: menu.items.map(item => patches.reduce((item, patch) => patch.id === item.id ? { ...item, ...patch } : item, item)) }));
+}

package/vendor/node_modules/@legendapp/spark-notifications/RNDesktopNotifications.podspec

@@ -0,0 +1,17 @@
+require "json"
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+Pod::Spec.new do |s|
+  s.name = "RNDesktopNotifications"
+  s.version = package["version"]
+  s.summary = "Desktop notifications"
+  s.license = { :type => "MIT" }
+  s.author = "Legend"
+  s.homepage = "https://legendapp.com"
+  s.source = { :path => "." }
+  s.platforms = { :osx => "14.0" }
+  s.source_files = "macos/**/*.{h,m,mm}"
+  s.dependency "React-Core"
+  s.dependency "ReactCodegen"
+  s.dependency "RNDesktopApp"
+  s.frameworks = "UserNotifications"
+end

package/vendor/node_modules/@legendapp/spark-notifications/macos/RNDesktopNotifications.h

@@ -0,0 +1,4 @@
+#import <RNDesktopNotificationsSpec/RNDesktopNotificationsSpec.h>
+#import <Foundation/Foundation.h>
+@interface RNDesktopNotifications : NSObject <NativeDesktopNotificationsSpec>
+@end

package/vendor/node_modules/@legendapp/spark-notifications/macos/RNDesktopNotifications.mm

@@ -0,0 +1,111 @@
+#import "RNDesktopNotifications.h"
+#import <RNDesktopApp/SparkDesktop.h>
+#import <UserNotifications/UserNotifications.h>
+
+static NSString * const NamespaceKey = @"sparkProject";
+static NSString *Permission(UNNotificationSettings *settings) {
+  switch (settings.authorizationStatus) {
+    case UNAuthorizationStatusNotDetermined: return @"notDetermined";
+    case UNAuthorizationStatusDenied: return @"denied";
+    case UNAuthorizationStatusAuthorized: return @"authorized";
+    case UNAuthorizationStatusProvisional: return @"provisional";
+    default: return @"unknown";
+  }
+}
+static NSString *Identifier(NSString *value) { return [NSString stringWithFormat:@"%@:%@", SparkNamespace(), value]; }
+static BOOL Owns(UNNotificationRequest *request) { return [request.content.userInfo[NamespaceKey] isEqual:SparkNamespace()]; }
+@interface SparkNotificationCenter : NSObject <UNUserNotificationCenterDelegate>
+@property NSMutableArray *responses;
+@property (weak) id<UNUserNotificationCenterDelegate> previous;
++ (instancetype)shared;
+@end
+@implementation SparkNotificationCenter
++ (instancetype)shared {
+  static SparkNotificationCenter *instance;
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    instance = [SparkNotificationCenter new]; instance.responses = [NSMutableArray new];
+    UNUserNotificationCenter *center = UNUserNotificationCenter.currentNotificationCenter;
+    instance.previous = center.delegate; center.delegate = instance;
+    [center getNotificationCategoriesWithCompletionHandler:^(NSSet<UNNotificationCategory *> *categories) {
+      NSMutableSet *combined = [categories mutableCopy];
+      [combined addObject:[UNNotificationCategory categoryWithIdentifier:@"spark.desktop.default" actions:@[] intentIdentifiers:@[] options:UNNotificationCategoryOptionCustomDismissAction]];
+      [center setNotificationCategories:combined];
+    }];
+  });
+  return instance;
+}
++ (void)load {
+  // Install before launch finishes, including when a notification launches the app.
+  [NSNotificationCenter.defaultCenter addObserverForName:NSApplicationWillFinishLaunchingNotification object:nil queue:NSOperationQueue.mainQueue usingBlock:^(NSNotification *note) { [self shared]; }];
+}
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completion {
+  if (Owns(notification.request)) completion(UNNotificationPresentationOptionBanner | UNNotificationPresentationOptionList | UNNotificationPresentationOptionSound);
+  else if ([self.previous respondsToSelector:_cmd]) [self.previous userNotificationCenter:center willPresentNotification:notification withCompletionHandler:completion];
+  else completion(UNNotificationPresentationOptionNone);
+}
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completion {
+  if (!Owns(response.notification.request)) {
+    if ([self.previous respondsToSelector:_cmd]) [self.previous userNotificationCenter:center didReceiveNotificationResponse:response withCompletionHandler:completion];
+    else completion();
+    return;
+  }
+  NSDictionary *info = response.notification.request.content.userInfo;
+  NSDictionary *event = @{ @"type": @"notificationResponse", @"id": NSUUID.UUID.UUIDString,
+    @"notificationId": info[@"sparkId"] ?: @"", @"data": info[@"sparkData"] ?: @{},
+    @"action": [response.actionIdentifier isEqual:UNNotificationDismissActionIdentifier] ? @"dismiss" : @"open" };
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self.responses addObject:event]; if (self.responses.count > 100) [self.responses removeObjectAtIndex:0];
+    SparkEmit(event); completion();
+  });
+}
+@end
+
+@implementation RNDesktopNotifications
+RCT_EXPORT_MODULE(NativeDesktopNotifications)
++ (BOOL)requiresMainQueueSetup { return YES; }
+- (void)call:(NSString *)method args:(NSString *)json resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    SparkNotificationCenter *delegate = [SparkNotificationCenter shared];
+    UNUserNotificationCenter *center = UNUserNotificationCenter.currentNotificationCenter;
+    NSDictionary *args = SparkArgs(json);
+    if ([method isEqual:@"permission"] || [method isEqual:@"requestPermission"]) {
+      void (^read)(void) = ^{ [center getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings *settings) { resolve(SparkJSON(Permission(settings))); }]; };
+      if ([method isEqual:@"permission"]) read();
+      else [center requestAuthorizationWithOptions:UNAuthorizationOptionAlert | UNAuthorizationOptionSound completionHandler:^(BOOL granted, NSError *error) { if (error) SparkReject(reject, error); else read(); }];
+    } else if ([method isEqual:@"show"]) {
+      if (![args[@"id"] isKindOfClass:NSString.class] || ![args[@"title"] isKindOfClass:NSString.class]) { SparkInvalid(reject, @"Notification needs an id and title"); return; }
+      UNMutableNotificationContent *content = [UNMutableNotificationContent new];
+      content.categoryIdentifier = @"spark.desktop.default";
+      content.title = args[@"title"]; content.body = args[@"body"] ?: @""; content.subtitle = args[@"subtitle"] ?: @"";
+      if ([args[@"sound"] boolValue]) content.sound = UNNotificationSound.defaultSound;
+      content.userInfo = @{ NamespaceKey: SparkNamespace(), @"sparkId": args[@"id"], @"sparkData": args[@"data"] ?: @{} };
+      UNNotificationTrigger *trigger = args[@"delay"] ? [UNTimeIntervalNotificationTrigger triggerWithTimeInterval:[args[@"delay"] doubleValue] repeats:NO] : nil;
+      UNNotificationRequest *request = [UNNotificationRequest requestWithIdentifier:Identifier(args[@"id"]) content:content trigger:trigger];
+      [center getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings *settings) {
+        if (settings.authorizationStatus != UNAuthorizationStatusAuthorized && settings.authorizationStatus != UNAuthorizationStatusProvisional) { reject(@"E_NOTIFICATION_PERMISSION", @"Request notification permission from a user action before showing notifications", nil); return; }
+        [center addNotificationRequest:request withCompletionHandler:^(NSError *error) { if (error) SparkReject(reject, error); else resolve(@"null"); }];
+      }];
+    } else if ([method isEqual:@"cancel"]) {
+      [center removePendingNotificationRequestsWithIdentifiers:@[Identifier(args[@"id"])]];
+      [center removeDeliveredNotificationsWithIdentifiers:@[Identifier(args[@"id"])]]; resolve(@"null");
+    } else if ([method isEqual:@"pending"] || [method isEqual:@"delivered"] || [method isEqual:@"clear"]) {
+      BOOL clear = [method isEqual:@"clear"];
+      if ([method isEqual:@"pending"] || clear) [center getPendingNotificationRequestsWithCompletionHandler:^(NSArray<UNNotificationRequest *> *requests) {
+        NSMutableArray *ids = [NSMutableArray new]; NSMutableArray *nativeIds = [NSMutableArray new];
+        for (UNNotificationRequest *request in requests) if (Owns(request)) { [ids addObject:request.content.userInfo[@"sparkId"]]; [nativeIds addObject:request.identifier]; }
+        if (clear) [center removePendingNotificationRequestsWithIdentifiers:nativeIds]; else resolve(SparkJSON(ids));
+        if (clear) [center getDeliveredNotificationsWithCompletionHandler:^(NSArray<UNNotification *> *notifications) {
+          NSMutableArray *delivered = [NSMutableArray new]; for (UNNotification *notification in notifications) if (Owns(notification.request)) [delivered addObject:notification.request.identifier];
+          [center removeDeliveredNotificationsWithIdentifiers:delivered]; resolve(@"null");
+        }];
+      }];
+      else [center getDeliveredNotificationsWithCompletionHandler:^(NSArray<UNNotification *> *notifications) {
+        NSMutableArray *ids = [NSMutableArray new]; for (UNNotification *notification in notifications) if (Owns(notification.request)) [ids addObject:notification.request.content.userInfo[@"sparkId"]]; resolve(SparkJSON(ids));
+      }];
+    } else if ([method isEqual:@"responses"]) resolve(SparkJSON([delegate.responses copy]));
+    else SparkInvalid(reject, @"Unknown notification operation");
+  });
+}
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params { return std::make_shared<facebook::react::NativeDesktopNotificationsSpecJSI>(params); }
+@end

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

@@ -0,0 +1,46 @@
+{
+  "name": "@legendapp/spark-notifications",
+  "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": "RNDesktopNotificationsSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "ios": {
+      "modulesProvider": {
+        "NativeDesktopNotifications": "RNDesktopNotifications"
+      }
+    }
+  },
+  "spark": {
+    "sdk": true,
+    "nativeModules": [
+      "NativeDesktopNotifications"
+    ],
+    "pod": "RNDesktopNotifications",
+    "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-notifications/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-notifications/src/NativeDesktopNotifications.ts

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

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

@@ -0,0 +1,53 @@
+import Native from "./NativeDesktopNotifications";
+import { Platform } from "react-native";
+import { onDesktopEvent, callApp } from "@legendapp/spark-desktop-app";
+
+export type NotificationPermission = "notDetermined" | "denied" | "authorized" | "provisional" | "unknown";
+export type DesktopNotification = {
+  id: string;
+  title: string;
+  body?: string;
+  subtitle?: string;
+  sound?: boolean;
+  /** Deliver after this many seconds, or immediately when omitted. */
+  delay?: number;
+  data?: Record<string, string>;
+};
+export type NotificationResponse = { type: "notificationResponse"; id: string; notificationId: string; action: "open" | "dismiss"; data: Record<string, string> };
+async function call<T = void>(method: string, args: object = {}): Promise<T> {
+  return JSON.parse(await Native.call(method, JSON.stringify(args))) as T;
+}
+function validId(id: string) {
+  if (!/^[a-zA-Z0-9_.-]{1,100}$/.test(id)) throw new Error("Notification id must contain 1–100 letters, numbers, dots, underscores or hyphens");
+  return id;
+}
+export const getNotificationPermission = () => call<NotificationPermission>("permission");
+/** Call from an explicit user action. Go shares its host's OS permission. */
+export const requestNotificationPermission = () => call<NotificationPermission>("requestPermission");
+export function showNotification(notification: DesktopNotification) {
+  validId(notification.id);
+  if (!notification.title?.trim()) throw new Error("Notification title is required");
+  if (notification.delay !== undefined && (!Number.isFinite(notification.delay) || notification.delay < 1)) throw new Error("Notification delay must be at least one second");
+  if (notification.data && Object.values(notification.data).some(value => typeof value !== "string")) throw new Error("Notification data values must be strings");
+  return call("show", notification);
+}
+/** Removes pending and delivered notifications with this project-scoped id. */
+export const cancelNotification = (id: string) => call("cancel", { id: validId(id) });
+export const clearNotifications = () => call("clear");
+export const getPendingNotifications = () => call<string[]>("pending");
+export const getDeliveredNotifications = () => call<string[]>("delivered");
+/** Subscribe before draining cold-launch responses; each subscription deduplicates overlap. */
+export async function onNotificationResponse(listener: (response: NotificationResponse) => void) {
+  let removed = false;
+  const seen = new Set<string>();
+  function receive(response: NotificationResponse) {
+    if (removed || seen.has(response.id)) return;
+    seen.add(response.id);
+    if (seen.size > 256) seen.delete(seen.values().next().value!);
+    listener(response);
+  }
+  const sub = onDesktopEvent(event => { if (event.type === "notificationResponse") receive(event as NotificationResponse); });
+  try { for (const response of (Platform.OS === "windows" ? await callApp<NotificationResponse[]>("notificationResponses") : await call<NotificationResponse[]>("responses"))) receive(response); }
+  catch (error) { sub.remove(); throw error; }
+  return { remove() { removed = true; sub.remove(); } };
+}

package/vendor/node_modules/@legendapp/spark-notifications/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-notifications/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-notifications/windows/SparkNotifications/ReactPackageProvider.cpp

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

package/vendor/node_modules/@legendapp/spark-notifications/windows/SparkNotifications/ReactPackageProvider.h

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

package/vendor/node_modules/@legendapp/spark-notifications/windows/SparkNotifications/ReactPackageProvider.idl

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

package/vendor/node_modules/@legendapp/spark-notifications/windows/SparkNotifications/SparkNotifications.cpp

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

package/vendor/node_modules/@legendapp/spark-notifications/windows/SparkNotifications/SparkNotifications.def

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