@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-desktop-config/schema.json

@@ -0,0 +1,305 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Desktop application configuration",
+  "type": "object",
+  "required": [
+    "projectId"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "name": {
+      "type": "string"
+    },
+    "projectId": {
+      "type": "string"
+    },
+    "version": {
+      "type": "string"
+    },
+    "window": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "width": {
+          "type": "number",
+          "minimum": 100,
+          "maximum": 20000
+        },
+        "height": {
+          "type": "number",
+          "minimum": 100,
+          "maximum": 20000
+        },
+        "minWidth": {
+          "type": "number",
+          "minimum": 100,
+          "maximum": 20000
+        },
+        "minHeight": {
+          "type": "number",
+          "minimum": 100,
+          "maximum": 20000
+        },
+        "maxWidth": {
+          "type": "number",
+          "minimum": 100,
+          "maximum": 20000
+        },
+        "maxHeight": {
+          "type": "number",
+          "minimum": 100,
+          "maximum": 20000
+        },
+        "resizable": {
+          "type": "boolean"
+        },
+        "closable": {
+          "type": "boolean"
+        },
+        "minimizable": {
+          "type": "boolean"
+        },
+        "alwaysOnTop": {
+          "type": "boolean"
+        },
+        "transparent": {
+          "type": "boolean"
+        },
+        "hasShadow": {
+          "type": "boolean"
+        },
+        "trafficLights": {
+          "type": "boolean"
+        },
+        "restoreFrame": {
+          "type": "boolean"
+        },
+        "titleBarStyle": {
+          "enum": [
+            "default",
+            "overlay",
+            "hidden",
+            "borderless"
+          ]
+        },
+        "appearance": {
+          "enum": [
+            "system",
+            "light",
+            "dark"
+          ]
+        },
+        "material": {
+          "enum": [
+            "none",
+            "sidebar",
+            "windowBackground",
+            "hudWindow",
+            "popover"
+          ]
+        },
+        "title": {
+          "type": "string"
+        },
+        "backgroundColor": {
+          "type": "string",
+          "pattern": "^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$"
+        }
+      }
+    },
+    "macos": {
+      "type": "object",
+      "required": [
+        "bundleIdentifier"
+      ],
+      "properties": {
+        "bundleIdentifier": {
+          "type": "string"
+        },
+        "buildNumber": {
+          "type": "string"
+        },
+        "entitlements": {
+          "type": "object"
+        },
+        "infoPlist": {
+          "type": "object"
+        }
+      }
+    },
+    "scheme": {
+      "oneOf": [
+        {
+          "type": "string"
+        },
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      ]
+    },
+    "documentTypes": {
+      "type": "array"
+    },
+    "menuBarOnly": {
+      "type": "boolean"
+    },
+    "updates": {
+      "type": "object",
+      "required": [
+        "feedURL",
+        "publicKey"
+      ],
+      "properties": {
+        "feedURL": {
+          "type": "string"
+        },
+        "publicKey": {
+          "type": "string"
+        }
+      }
+    },
+    "include": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "helpers": {
+      "type": "object",
+      "propertyNames": {
+        "pattern": "^[A-Za-z0-9_-]+$"
+      },
+      "additionalProperties": {
+        "oneOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "object",
+            "minProperties": 1,
+            "propertyNames": {
+              "enum": [
+                "macos-arm64",
+                "macos-x64",
+                "windows-arm64",
+                "windows-x64"
+              ]
+            },
+            "additionalProperties": {
+              "type": "object",
+              "required": [
+                "directory",
+                "executable"
+              ],
+              "additionalProperties": false,
+              "properties": {
+                "directory": {
+                  "type": "string"
+                },
+                "executable": {
+                  "type": "string"
+                }
+              }
+            }
+          }
+        ]
+      }
+    },
+    "signing": {
+      "type": "object"
+    },
+    "expo": {
+      "type": "object"
+    },
+    "platforms": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "enum": [
+          "ios",
+          "android",
+          "web",
+          "macos",
+          "windows"
+        ]
+      }
+    },
+    "expoByPlatform": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "ios": {
+          "type": "object"
+        },
+        "android": {
+          "type": "object"
+        },
+        "web": {
+          "type": "object"
+        },
+        "macos": {
+          "type": "object"
+        },
+        "windows": {
+          "type": "object"
+        }
+      }
+    },
+    "extends": {
+      "const": "expo",
+      "description": "Compose desktop options onto the existing Expo configuration."
+    }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "platforms": {
+            "const": [
+              "windows"
+            ]
+          }
+        },
+        "required": [
+          "platforms"
+        ]
+      },
+      "then": {},
+      "else": {
+        "required": [
+          "macos"
+        ]
+      }
+    },
+    {
+      "if": {
+        "required": [
+          "extends"
+        ],
+        "properties": {
+          "extends": {
+            "const": "expo"
+          }
+        }
+      },
+      "then": {
+        "required": [
+          "platforms"
+        ]
+      },
+      "else": {
+        "required": [
+          "name",
+          "version"
+        ]
+      }
+    }
+  ]
+}

package/vendor/node_modules/@legendapp/spark-desktop-config/updates.cjs

@@ -0,0 +1,24 @@
+function updateConfiguration(expo) {
+  const updates = expo.extra?.spark?.updates;
+  if (updates === undefined) return undefined;
+  if (!updates || typeof updates !== "object" || Array.isArray(updates)) throw new Error("extra.spark.updates must be an object");
+  let url;
+  try { url = new URL(updates.feedURL); } catch { throw new Error("Updates need an HTTPS feedURL"); }
+  if (url.protocol !== "https:" || !url.hostname || url.username || url.password || url.search || url.hash || !url.pathname.endsWith(".xml")) throw new Error("Update feedURL must be an HTTPS .xml URL without credentials, query or fragment");
+  if (typeof updates.publicKey !== "string" || !/^[A-Za-z0-9+/]{43}=$/.test(updates.publicKey) || Buffer.from(updates.publicKey, "base64").length !== 32) throw new Error("Updates need a base64 Ed25519 publicKey; run spark updates init <feedURL>");
+  return { feedURL: url.href, publicKey: updates.publicKey };
+}
+function updatePlist(expo) {
+  const updates = updateConfiguration(expo);
+  return updates ? {
+    SUFeedURL: updates.feedURL,
+    SUPublicEDKey: updates.publicKey,
+    SUEnableAutomaticChecks: false,
+    SUAutomaticallyUpdate: false,
+    SUAllowsAutomaticUpdates: false,
+    SUEnableSystemProfiling: false,
+    SURequireSignedFeed: true,
+    SUVerifyUpdateBeforeExtraction: true,
+  } : {};
+}
+module.exports = { updateConfiguration, updatePlist };

package/vendor/node_modules/@legendapp/spark-desktop-config/windows.plugin.cjs

@@ -0,0 +1,72 @@
+const { statePath } = require("./config.cjs");
+const fs = require('node:fs');
+const path = require('node:path');
+
+function patchHost(source, core, metadata, defaults = {}) {
+  source = source.replace(/\r\n/g, '\n').replace(/\n\/\/ BEGIN SPARK CORE[\s\S]*?\/\/ END SPARK CORE\n/g, '')
+    .replace(/\n  \/\/ BEGIN SPARK TITLE[\s\S]*?\/\/ END SPARK TITLE\n/g, '')
+    .replace(/\n  \/\/ BEGIN SPARK CONNECTION[\s\S]*?\/\/ END SPARK CONNECTION\n/g, '');
+  source = source.replace(/\n    \/\/ BEGIN SPARK RUNTIMES[\s\S]*?\/\/ END SPARK RUNTIMES\n/g, '');
+  const include = '#include "NativeModules.h"';
+  const launchAnchor = 'winrt::init_apartment(winrt::apartment_type::single_threaded);';
+  const anchor = 'auto settings{reactNativeWin32App.ReactNativeHost().InstanceSettings()};';
+  if (!source.includes(include) || !source.includes(anchor) || !source.includes(launchAnchor) || (!source.includes("SparkWin::Initialize(reactNativeWin32App);") && !/appWindow\.Resize\([^\n]+\);/.test(source))) throw new Error('The pinned Windows host template changed; cannot install the Spark host hooks.');
+  if (!['go', 'dev'].includes(metadata.mode) || !/^[a-f0-9]{64}$/.test(metadata.fingerprint)) throw new Error('Invalid Windows runtime build metadata');
+  source = source.replace(/appWindow\.Title\([^\n]+\);/, title => `${title}\n  // BEGIN SPARK TITLE\n  const auto sparkTitle = SparkWindowsEnv(L"SPARK_PROJECT_NAME");\n  if (!sparkTitle.empty()) appWindow.Title(sparkTitle);\n  // END SPARK TITLE\n`);
+  source = source.replace('SparkWin::Initialize(reactNativeWin32App);', 'appWindow.Resize({1000, 1000});');
+  source = source.replace(/appWindow\.Resize\([^\n]+\);/, 'SparkWin::Initialize(reactNativeWin32App);');
+  source = source.replace(/\n  \/\/ BEGIN SPARK LAUNCH[\s\S]*?\/\/ END SPARK LAUNCH\n/g, '');
+  source = source.replace('winrt::init_apartment(winrt::apartment_type::single_threaded);', 'winrt::init_apartment(winrt::apartment_type::single_threaded);\n  // BEGIN SPARK LAUNCH\n  try { SparkInitializeEnvironment(); if (SparkWin::ForwardLaunch()) return 0; SparkWin::InitializeToastActivation(); }\n  catch (winrt::hresult_error const &error) { MessageBoxW(nullptr, error.message().c_str(), L"Spark launch failed", MB_OK | MB_ICONERROR); return 1; }\n  // END SPARK LAUNCH\n');
+  source = source.replace(anchor, `${anchor}\n  // BEGIN SPARK CONNECTION\n  settings.SourceBundleHost(L"127.0.0.1");\n  settings.SourceBundlePort(SparkMetroPort());\n  // END SPARK CONNECTION\n`);
+  if (core.includes('static void RegisterRuntimeSurface(')) {
+    if (!source.includes('AddAttributedModules(packageBuilder, true);')) throw new Error('The pinned Windows host template changed; cannot register runtime surfaces.');
+    source = source.replace('AddAttributedModules(packageBuilder, true);', 'AddAttributedModules(packageBuilder, true);\n    // BEGIN SPARK RUNTIMES\n    SparkWin::RegisterRuntimeSurface(packageBuilder);\n    // END SPARK RUNTIMES\n');
+  }
+  // Only patch the upstream template. Embedded host source can contain the same
+  // API calls and must never be matched by these template replacements.
+  return source.replace(include, `${include}\n// BEGIN SPARK CORE\n${core.replace('__SPARK_METADATA__', JSON.stringify(metadata)).replace('__SPARK_PROJECT_CONFIG__', JSON.stringify({ ...defaults, SPARK_RUNTIME_MODE: metadata.mode }).replaceAll(')', '\\u0029').replace(/[^\x00-\x7F]/g, char => '\\u' + char.charCodeAt(0).toString(16).padStart(4, '0')))}\n// END SPARK CORE\n`);
+}
+module.exports = config => {
+  const { withAppCpp } = require('expo-desktop-config-plugins');
+  config = withAppCpp(config, mod => {
+    const root = mod.modRequest.projectRoot;
+    const metadata = JSON.parse(fs.readFileSync(statePath(root, 'windows-build-input.json', 'windows'), 'utf8'));
+    const { expo } = require('./config.cjs').readConfig(root);
+    const defaults = metadata.mode === 'dev' ? {
+      SPARK_PROJECT_ID: expo.extra.spark.projectId, SPARK_PROJECT_NAME: expo.name,
+      SPARK_PROJECT_VERSION: expo.version, SPARK_WINDOW_CONFIG: JSON.stringify(expo.extra.spark.window ?? {}),
+      SPARK_SESSION_FILE: statePath(root, 'windows-connection.json', 'windows'),
+    } : {};
+    mod.modResults.contents = patchHost(mod.modResults.contents, fs.readFileSync(require.resolve('@legendapp/spark-desktop-host/windows/runtime.inc'), 'utf8') + '\n' + fs.readFileSync(require.resolve('@legendapp/spark-desktop-host/windows/application.inc'), 'utf8') + '\n' + fs.readFileSync(require.resolve('@legendapp/spark-desktop-host/windows/notifications.inc'), 'utf8') + (Object.hasOwn(metadata.modules ?? {}, '@react-native-runtimes/core') ? '\n' + fs.readFileSync(require.resolve('@legendapp/spark-desktop-host/windows/runtimes.inc'), 'utf8') : ''), metadata, defaults);
+    return mod;
+  });
+  const { withMod } = require('@expo/config-plugins');
+  config = withMod(config, { platform: 'windows', mod: 'vcxproj', action: mod => {
+    unpackagedApp(mod.modResults);
+    return mod;
+  }});
+  return withMod(config, { platform: 'windows', mod: 'sln', action: mod => {
+    mod.modResults.contents = withoutPackaging(mod.modResults.contents);
+    return mod;
+  }});
+};
+function withoutPackaging(source) {
+  const guids = [];
+  source = source.replace(/Project\([^\n]+\) = [^\n]*\.wapproj[^\n]*, "(\{[^}]+\})"\r?\n[\s\S]*?EndProject\r?\n/g, (_match, guid) => { guids.push(guid.toUpperCase()); return ''; });
+  return source.split(/(?<=\n)/).filter(line => !guids.some(guid => line.toUpperCase().includes(guid))).join('');
+}
+module.exports.withoutPackaging = withoutPackaging;
+module.exports.patchHost = patchHost;
+
+function unpackagedApp(document) {
+  const project = document.find(node => node.Project)?.Project;
+  const globals = project?.find(node => node.PropertyGroup && node[':@']?.['@_Label'] === 'Globals')?.PropertyGroup;
+  if (!globals) throw new Error('The pinned Windows app project has no Globals property group');
+  // These apply only to the executable, never the autolinked library projects.
+  for (const [key, value] of Object.entries({ WindowsPackageType: 'None', WindowsAppSDKSelfContained: 'true' })) {
+    const existing = globals.find(node => key in node);
+    if (existing) existing[key] = [{ '#text': value }];
+    else globals.push({ [key]: [{ '#text': value }] });
+  }
+}
+module.exports.unpackagedApp = unpackagedApp;

package/vendor/node_modules/@legendapp/spark-desktop-host/AppDelegate.mm

@@ -0,0 +1,79 @@
+#import "AppDelegate.h"
+#import <RNDesktopApp/SparkDesktop.h>
+#import <React/RCTBundleURLProvider.h>
+#import <React-RCTAppDelegate/RCTRootViewFactory.h>
+#import <ReactAppDependencyProvider/RCTAppDependencyProvider.h>
+
+#if __has_include(<NativeComposeThreadedRuntime/ThreadedRuntime.h>)
+#import <NativeComposeThreadedRuntime/ThreadedRuntime.h>
+#import <React/RCTReloadCommand.h>
+#endif
+
+@implementation AppDelegate
+- (void)applicationDidFinishLaunching:(NSNotification *)notification
+{
+  if (!SparkAcquireInstance()) { [NSApp terminate:nil]; return; }
+  SparkMarkLaunchComplete();
+  self.moduleName = @"main";
+  self.dependencyProvider = [RCTAppDependencyProvider new];
+  self.initialProps = SparkInitialProps(@"main", @{});
+#if __has_include(<NativeComposeThreadedRuntime/ThreadedRuntime.h>)
+  [ThreadedRuntime configureWithReactNativeDelegate:self launchOptions:@{}];
+  // Fired before React Native enumerates reload listeners, so workers are
+  // discarded before the main app restarts. Worker invalidation owns no app UI.
+  [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(sparkResetRuntimes:)
+    name:RCTTriggerReloadCommandNotification object:nil];
+#endif
+  [super applicationDidFinishLaunching:notification];
+}
+#if __has_include(<NativeComposeThreadedRuntime/ThreadedRuntime.h>)
+- (void)sparkResetRuntimes:(NSNotification *)notification { [ThreadedRuntime destroyAllRuntimes]; }
+- (void)applicationWillTerminate:(NSNotification *)notification { [ThreadedRuntime destroyAllRuntimes]; }
+#endif
+- (void)loadReactNativeWindow:(NSDictionary *)launchOptions {
+  NSView *root = [self.rootViewFactory viewWithModuleName:self.moduleName initialProperties:self.initialProps launchOptions:launchOptions];
+  self.window = [[NSWindow alloc] initWithContentRect:NSMakeRect(0, 0, 1000, 700)
+    styleMask:NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | NSWindowStyleMaskResizable | NSWindowStyleMaskMiniaturizable
+    backing:NSBackingStoreBuffered defer:NO];
+  self.window.releasedWhenClosed = NO;
+  self.window.identifier = @"spark.main";
+  self.window.title = SparkContext()[@"name"];
+  root.frame = NSMakeRect(0, 0, 1000, 700);
+  self.window.contentView = SparkWindowContent(root);
+  NSDictionary *options = SparkWindowConfiguration();
+  SparkApplyWindowOptions(self.window, options);
+  SparkRestoreWindow(self.window, @"main", options);
+  if (![[NSBundle.mainBundle objectForInfoDictionaryKey:@"SparkMenuBarOnly"] boolValue]) [self.window makeKeyAndOrderFront:nil];
+}
+- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender { return SparkShouldQuit(); }
+- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)sender { return NO; }
+- (void)applicationDidBecomeActive:(NSNotification *)note { SparkEmit(@{ @"type": @"activate" }); }
+- (void)applicationDidResignActive:(NSNotification *)note { SparkEmit(@{ @"type": @"deactivate" }); }
+- (BOOL)applicationShouldHandleReopen:(NSApplication *)sender hasVisibleWindows:(BOOL)visible {
+  if (!visible) for (NSWindow *window in NSApp.windows) if ([window.identifier isEqual:@"spark.main"]) [window makeKeyAndOrderFront:nil];
+  SparkEmit(@{ @"type": @"reopen" }); return YES;
+}
+- (void)application:(NSApplication *)sender openURLs:(NSArray<NSURL *> *)urls { SparkOpenURLs(urls); }
+- (void)application:(NSApplication *)sender openFiles:(NSArray<NSString *> *)files {
+  NSMutableArray *urls = [NSMutableArray new];
+  for (NSString *file in files) [urls addObject:[NSURL fileURLWithPath:file]];
+  SparkOpenURLs(urls);
+  [sender replyToOpenOrPrint:NSApplicationDelegateReplySuccess];
+}
+- (NSURL *)sourceURLForBridge:(RCTBridge *)bridge { return [self bundleURL]; }
+- (NSURL *)bundleURL
+{
+#if DEBUG
+  NSString *value = NSProcessInfo.processInfo.environment[@"SPARK_BUNDLE_URL"];
+  NSURL *url = value.length ? [NSURL URLWithString:value] : nil;
+  if (url && ([@"127.0.0.1" isEqualToString:url.host] || [@"localhost" isEqualToString:url.host])) {
+    return url;
+  }
+  return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"];
+#else
+  return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
+#endif
+}
+- (NSMenu *)applicationDockMenu:(NSApplication *)sender { return SparkDockMenu; }
+- (BOOL)concurrentRootEnabled { return YES; }
+@end

package/vendor/node_modules/@legendapp/spark-desktop-host/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@legendapp/spark-desktop-host",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "files": [
+    "AppDelegate.mm",
+    "windows"
+  ],
+  "dependencies": {
+    "@legendapp/spark-desktop-app": "0.0.1-next.2"
+  },
+  "private": true
+}

package/vendor/node_modules/@legendapp/spark-desktop-host/windows/SparkComponentGeometry.h

@@ -0,0 +1,9 @@
+#pragma once
+#include <unknwn.h>
+#include <cstdint>
+#include <windef.h>
+// Private ABI for the pinned RNW adapter. Do not alter RNW's existing interfaces.
+struct __declspec(uuid("29DAD809-CE78-4F6F-89B4-5DC3BC7AC136")) ISparkComponentGeometry : IUnknown {
+  virtual RECT __stdcall SparkClientRect() noexcept = 0;
+  virtual int64_t __stdcall SparkHitTest(float x, float y, float *localX, float *localY) noexcept = 0;
+};