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

package/vendor/node_modules/@legendapp/spark-desktop-config/config.d.cts

@@ -1,13 +1,93 @@
-export function readConfig(root: string, target?: string): any;
-export function prepareConfig(root: string): any;
-export function toExpo(value: unknown, target?: string): any;
-export function writeUpdates(root: string, updates: unknown): void;
-
+import type { ExpoConfig } from "@expo/config-types";
+import type { WindowConfiguration } from "@legendapp/spark-window-options";
+export type { WindowConfiguration } from "@legendapp/spark-window-options";
+export type SparkPlatform = "macos" | "windows" | "ios" | "android" | "web";
+export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue };
+export interface UpdateConfiguration { feedURL: string; publicKey: string }
+export interface DocumentType { name: string; contentTypes: string[]; role?: "Editor" | "Viewer" }
+export type HelperTarget = "macos-arm64" | "macos-x64" | "windows-arm64" | "windows-x64";
+export type HelperConfiguration = string | Partial<Record<HelperTarget, { directory: string; executable: string }>>;
+export interface MacOSConfiguration {
+  bundleIdentifier: string;
+  buildNumber?: string;
+  infoPlist?: Record<string, JsonValue>;
+  entitlements?: Record<string, JsonValue>;
+  lifecycle?: MacOSLifecycle;
+}
+export interface SigningConfiguration {
+  macos?: { identity?: string; teamId?: string; entitlementsByPath?: Record<string, Record<string, JsonValue>> };
+}
+/** Spark-owned settings carried inside Expo's extra.spark. */
+export interface SparkSettings {
+  projectId: string;
+  window?: WindowConfiguration;
+  documentTypes?: DocumentType[];
+  menuBarOnly?: boolean;
+  updates?: UpdateConfiguration;
+  include?: string[];
+  signing?: SigningConfiguration;
+  helpers?: Record<string, HelperConfiguration>;
+  supportedPlatforms?: SparkPlatform[];
+}
+/** Expo retains ownership of its configuration; Spark only adds desktop fields. */
+export type ExpoOverrides = Partial<Omit<ExpoConfig, "platforms" | "extra">> & {
+  platforms?: SparkPlatform[];
+  extra?: Record<string, unknown>;
+  macos?: MacOSConfiguration;
+  windows?: { namespace?: string; displayName?: string; packageGuid?: string; projectGuid?: string; [key: string]: unknown };
+  autolinking?: { exclude?: string[]; [key: string]: unknown };
+};
+export interface SparkApplicationConfig extends Omit<SparkSettings, "supportedPlatforms"> {
+  $schema?: string;
+  name: string;
+  version: string;
+  extends?: never;
+  platforms?: SparkPlatform[];
+  macos?: MacOSConfiguration;
+  scheme?: string | string[];
+  expo?: ExpoOverrides;
+  expoByPlatform?: Partial<Record<SparkPlatform, ExpoOverrides>>;
+}
+export type SparkExpoProjectConfig = Omit<SparkApplicationConfig, "extends" | "name" | "version" | "platforms"> & {
+  extends: "expo";
+  name?: string;
+  version?: string;
+  platforms: SparkPlatform[];
+};
+export type SparkConfig = SparkApplicationConfig | SparkExpoProjectConfig;
+export type ResolvedExpoConfig = Omit<ExpoOverrides, "platforms" | "extra"> & {
+  platforms: SparkPlatform[];
+  extra?: Record<string, unknown> & { spark?: SparkSettings };
+};
+export interface ResolvedConfig { expo: ResolvedExpoConfig }
+export type GeneratedExpoConfig = ResolvedExpoConfig & { name: string; slug: string; version: string; extra: Record<string, unknown> & { spark: SparkSettings } };
+export function readConfig(root: string, target?: string): ResolvedConfig;
+export function prepareConfig(root: string): ResolvedConfig;
+/** Accepts untrusted JSON; validates Spark-owned settings before returning Expo configuration. */
+export function toExpo(value: unknown, target?: string): { expo: GeneratedExpoConfig };
+export function writeUpdates(root: string, updates: UpdateConfiguration): void;
 export function isUniversal(root: string): boolean;
 export function isExpoProject(root: string): boolean;
 export function statePath(root: string, name: string, target?: string): string;
-export function selectTarget(platforms: string[], target?: string): string;
-export function expoConfig(root: string): any;
+export function selectTarget(platforms: readonly string[], target?: string): SparkPlatform;
+export function expoConfig(root: string): ResolvedExpoConfig;
+export function supportedPlatforms(root: string): SparkPlatform[];
+export function developmentConfig(value: unknown, target?: string): GeneratedExpoConfig;
+export function applySelection(root: string, expo: ResolvedExpoConfig): ResolvedExpoConfig;
 
-export function supportedPlatforms(root: string): string[];
-export function developmentConfig(value: any, target?: string): any;
+/** macOS native startup policy. Omitted fields keep Spark's normal host behavior. */
+export type MacOSLifecycle = {
+  appearance?: "system" | "light" | "dark";
+  /** Linked NSObject classes conforming to SparkStartupPlugin. No automatic discovery. */
+  plugins?: string[];
+  mainWindow?: {
+    hidden?: boolean;
+    glass?: boolean;
+    autosaveName?: string;
+    backgroundColors?: { light: string; dark: string };
+    closeBehavior?: "close" | "hide" | "request";
+    reopenBehavior?: "default" | "manual" | "visibleWindows";
+    toolbarStyle?: "unified" | "expanded";
+    titlebarSeparatorStyle?: "automatic" | "none" | "line" | "shadow";
+  };
+};

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

@@ -5,6 +5,7 @@ const path = require('node:path');
 // Only an explicitly selected desktop command applies the Spark overlay.
 function withSparkExpo(original, root) {
   return context => {
+    require('./native-patches.cjs').prepareNativePatches(root);
     const base = typeof original === 'function' ? original(context) : original;
     const target = process.env.SPARK_PLATFORM;
     const development = process.env.SPARK_DEV_SESSION === '1';

package/vendor/node_modules/@legendapp/spark-desktop-config/expo.d.cts

@@ -0,0 +1,3 @@
+import type { ExpoOverrides } from "./config.cjs";
+/** Compose Spark's desktop overlay without replacing Expo's configuration model. */
+export function withSparkExpo<Context>(original: ExpoOverrides | ((context: Context) => ExpoOverrides), root: string): (context: Context) => ExpoOverrides;

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

@@ -1,4 +1,4 @@
-const { validateWindow } = require("@legendapp/spark-window-options");
+const { nativeWindowOptions } = require("@legendapp/spark-window-options");
 const { updatePlist } = require("./updates.cjs");
 function identity(config) {
   const projectId = config.extra?.spark?.projectId ?? config.macos?.bundleIdentifier;
@@ -16,7 +16,8 @@ function identity(config) {
     LSUIElement: config.extra?.spark?.menuBarOnly === true,
     SparkMenuBarOnly: config.extra?.spark?.menuBarOnly === true,
     SparkProjectIdentifier: projectId,
-    SparkWindowConfiguration: validateWindow(config.extra?.spark?.window ?? {}),
+    SparkLifecycleConfiguration: require("./lifecycle.cjs").validateLifecycle(config.macos?.lifecycle),
+    SparkWindowConfiguration: nativeWindowOptions(config.extra?.spark?.window ?? {}),
     ...updatePlist(config),
     // The app may need JS to save edits before accepting a quit request.
     NSSupportsAutomaticTermination: false,

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

@@ -0,0 +1,20 @@
+// macOS startup policy is opt-in and separate from portable window styling.
+function validateLifecycle(value = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("macos.lifecycle must be an object");
+  for (const key of Object.keys(value)) if (!["plugins", "mainWindow", "appearance"].includes(key)) throw new Error(`Unknown lifecycle option: ${key}`);
+  if (value.plugins !== undefined && (!Array.isArray(value.plugins) || value.plugins.some(name => typeof name !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) || new Set(value.plugins).size !== value.plugins.length)) throw new Error("lifecycle.plugins must contain unique native class names");
+  if (value.appearance !== undefined && !["system", "light", "dark"].includes(value.appearance)) throw new Error("Invalid application appearance");
+  const window = value.mainWindow ?? {};
+  if (!window || typeof window !== "object" || Array.isArray(window)) throw new Error("lifecycle.mainWindow must be an object");
+  const enums = { closeBehavior: ["close", "hide", "request"], reopenBehavior: ["default", "manual", "visibleWindows"], toolbarStyle: ["unified", "expanded"], titlebarSeparatorStyle: ["automatic", "none", "line", "shadow"] };
+  for (const key of Object.keys(window)) if (!["hidden", "glass", "autosaveName", "backgroundColors", ...Object.keys(enums)].includes(key)) throw new Error(`Unknown mainWindow option: ${key}`);
+  for (const key of ["hidden", "glass"]) if (window[key] !== undefined && typeof window[key] !== "boolean") throw new Error(`${key} must be a boolean`);
+  for (const [key, values] of Object.entries(enums)) if (window[key] !== undefined && !values.includes(window[key])) throw new Error(`Invalid ${key}`);
+  if (window.autosaveName !== undefined && (typeof window.autosaveName !== "string" || !window.autosaveName.length)) throw new Error("autosaveName must be a nonempty string");
+  if (window.backgroundColors !== undefined) {
+    const colors = window.backgroundColors;
+    if (!colors || typeof colors !== "object" || Array.isArray(colors) || Object.keys(colors).some(key => !["light", "dark"].includes(key)) || ["light", "dark"].some(key => typeof colors[key] !== "string" || !/^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/.test(colors[key]))) throw new Error("backgroundColors needs light and dark hex colors");
+  }
+  return value;
+}
+module.exports = { validateLifecycle };

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

@@ -0,0 +1,106 @@
+const { createHash } = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+const { createRequire } = require("node:module");
+
+const cameraPackages = ["react-native-nitro-image", "react-native-vision-camera"];
+
+function prepareNativePatches(root) {
+  const manifestFile = path.join(root, "package.json");
+  if (!fs.existsSync(manifestFile)) return {};
+  const app = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
+  if (app.name !== "@legendapp/spark" && !app.dependencies?.["@legendapp/spark"] && !app.devDependencies?.["@legendapp/spark"]) return {};
+  const appRequire = createRequire(manifestFile);
+  let sparkFile;
+  try { sparkFile = appRequire.resolve("@legendapp/spark/package.json"); }
+  catch (error) { if (error.code === "MODULE_NOT_FOUND") return {}; throw error; }
+  const spark = JSON.parse(fs.readFileSync(sparkFile, "utf8"));
+  const directory = path.dirname(sparkFile);
+  const patchesRoot = spark.spark?.bundledModuleRoot
+    ? path.join(directory, "patches") : path.resolve(__dirname, "../../patches");
+  const pins = {};
+  if (cameraPackages.some(name => spark.dependencies?.[name])) {
+    const cameraPins = JSON.parse(fs.readFileSync(path.join(patchesRoot, "camera/upstream.json"), "utf8"));
+    for (const name of ["react-native-nitro-modules", ...cameraPackages]) {
+      pins[name] = { ...cameraPins[name], patch: `camera/${name}.patch`,
+        requires: name === "react-native-vision-camera" ? ["react-native-nitro-modules", "react-native-nitro-image"] : ["react-native-nitro-modules"] };
+    }
+  }
+  const integrations = path.join(patchesRoot, "dependencies.json");
+  if (fs.existsSync(integrations)) Object.assign(pins, JSON.parse(fs.readFileSync(integrations, "utf8")));
+  const active = Object.keys(pins).filter(name => spark.dependencies?.[name]);
+  if (!active.length) return {};
+  const { parsePatch, applyPatch, reversePatch } = require("diff");
+  const queue = [appRequire, createRequire(sparkFile)];
+  const visited = new Set();
+  const packages = {};
+  for (const req of queue) {
+    for (const name of active) {
+      let file;
+      try { file = req.resolve(`${name}/package.json`); }
+      catch (error) {
+        if (error.code !== "MODULE_NOT_FOUND") throw error;
+        if (req === appRequire) continue;
+        throw new Error(`Spark needs ${name}@${pins[name].version}. Finish installing dependencies before native preparation.`);
+      }
+      if (!fs.existsSync(file)) throw new Error(`Spark needs ${name}@${pins[name].version}. Finish installing dependencies before native preparation.`);
+      const packageRoot = fs.realpathSync(path.dirname(file));
+      if (visited.has(packageRoot)) continue;
+      visited.add(packageRoot);
+      packages[name] = { root: packageRoot };
+      queue.push(createRequire(file));
+      const manifest = JSON.parse(fs.readFileSync(file, "utf8"));
+      const pin = pins[name];
+      if (manifest.version !== pin.version) throw new Error(`Spark needs ${name}@${pin.version}; found ${manifest.version}. Use the SDK's pinned dependency version.`);
+      const bytes = fs.readFileSync(path.join(patchesRoot, pin.patch));
+      const writes = [];
+      for (const patch of parsePatch(bytes.toString("utf8"))) {
+        const relative = patch.newFileName.replace(/^b\//, "");
+        const target = path.resolve(packageRoot, relative);
+        if (!target.startsWith(packageRoot + path.sep) || patch.newFileName === "/dev/null") throw new Error(`Invalid native patch target: ${relative}`);
+        let current = fs.existsSync(target) ? fs.readFileSync(target, "utf8") : "";
+        if (patch.oldFileName === "/dev/null") {
+          const next = applyPatch("", patch);
+          if (current === next) continue;
+          if (current !== "") throw new Error(`Cannot apply Spark's ${name} patch to ${relative}. Reinstall dependencies before retrying.`);
+          writes.push([target, next]);
+          continue;
+        }
+        if (relative === "package.json" && manifest.spark?.dependencyPatch) {
+          const original = JSON.parse(current);
+          delete original.spark.dependencyPatch;
+          delete original.spark.sdk;
+          delete original.spark.requires;
+          if (!Object.keys(original.spark).length) delete original.spark;
+          current = JSON.stringify(original, null, 2) + "\n";
+        }
+        if (applyPatch(current, reversePatch(patch)) !== false) continue;
+        const next = applyPatch(current, patch);
+        if (next === false) throw new Error(`Cannot apply Spark's ${name} patch to ${relative}. Reinstall dependencies before retrying.`);
+        writes.push([target, next]);
+      }
+      // Verify every file before writing; rename rather than mutate package-manager cache hardlinks.
+      for (const [target, next] of writes) {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        const temporary = `${target}.spark-${process.pid}.tmp`;
+        fs.writeFileSync(temporary, next); fs.renameSync(temporary, target);
+      }
+      const patched = JSON.parse(fs.readFileSync(file, "utf8"));
+      patched.spark ??= {};
+      if (name !== "react-native-nitro-modules") {
+        patched.spark.sdk = true;
+        patched.spark.requires = pin.requires ?? [];
+      }
+      patched.spark.dependencyPatch = { schema: 1, version: pin.version,
+        patchHash: createHash("sha256").update(bytes).digest("hex"), upstreamIntegrity: pin.integrity };
+      const serialized = JSON.stringify(patched, null, 2) + "\n";
+      if (fs.readFileSync(file, "utf8") !== serialized) {
+        const temporary = `${file}.spark-${process.pid}.tmp`;
+        fs.writeFileSync(temporary, serialized); fs.renameSync(temporary, file);
+      }
+    }
+  }
+  return packages;
+}
+
+module.exports = { prepareNativePatches };

package/vendor/node_modules/@legendapp/spark-desktop-config/native-patches.d.cts

@@ -0,0 +1 @@
+export function prepareNativePatches(root: string): Record<string, { root: string }>;

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

@@ -1,6 +1,6 @@
 {
   "name": "@legendapp/spark-desktop-config",
-  "version": "0.0.1-next.2",
+  "version": "0.0.1-next.4",
   "license": "MIT",
   "main": "app.plugin.cjs",
   "files": [
@@ -10,10 +10,12 @@
     "*.d.cts"
   ],
   "dependencies": {
-    "expo-desktop-config-plugins": "1.2.0-beta.1",
-    "@legendapp/spark-desktop-host": "0.0.1-next.2",
-    "@legendapp/spark-window-options": "0.0.1-next.2",
-    "@expo/config-plugins": "54.0.5"
+    "expo-desktop-config-plugins": "1.2.0",
+    "@legendapp/spark-desktop-host": "0.0.1-next.4",
+    "@legendapp/spark-window-options": "0.0.1-next.4",
+    "@expo/config-plugins": "54.0.5",
+    "@expo/config-types": "54.0.10",
+    "diff": "8.0.2"
   },
   "private": true
 }