@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-cli/dist/windows-metro.js

@@ -0,0 +1,112 @@
+import { readFileSync } from "node:fs";
+import http from "node:http";
+import https from "node:https";
+import WebSocket, { WebSocketServer } from "ws";
+export function windowsMetroURL(request, port, options) {
+    const source = new URL(request), target = new URL(`${options.https ? "https" : "http"}://127.0.0.1:${port}`);
+    target.pathname = source.pathname;
+    target.search = source.search;
+    if (/\.(bundle|map)$/.test(target.pathname)) {
+        target.searchParams.set("dev", String(options.dev ?? true));
+        target.searchParams.set("minify", String(options.minify ?? false));
+        if (options.dev === false)
+            target.searchParams.set("hot", "false");
+    }
+    return target;
+}
+export async function startWindowsMetro(port, options) {
+    const ca = options.https && process.env.SSL_CRT_FILE ? readFileSync(process.env.SSL_CRT_FILE, "utf8") : undefined;
+    const sockets = new Set();
+    const remotes = new Set();
+    const server = http.createServer((request, response) => {
+        const target = windowsMetroURL(`http://127.0.0.1${request.url}`, port, options);
+        const headers = { ...request.headers };
+        delete headers.host;
+        delete headers.connection;
+        // Raw streams retain Content-Encoding/Length and avoid fetch decompression.
+        const upstream = (options.https ? https : http).request(target, { method: request.method, headers, ...(ca ? { ca } : {}) }, incoming => {
+            response.writeHead(incoming.statusCode ?? 502, incoming.headers);
+            incoming.on("error", error => response.destroy(error));
+            incoming.pipe(response);
+        });
+        upstream.on("error", error => {
+            if (!response.headersSent) {
+                response.writeHead(502);
+                response.end(`Expo Metro connection failed: ${String(error)}`);
+            }
+            else
+                response.destroy(error);
+        });
+        request.on("error", () => upstream.destroy());
+        request.on("aborted", () => upstream.destroy());
+        response.on("close", () => { if (!response.writableEnded)
+            upstream.destroy(); });
+        request.pipe(upstream);
+    });
+    server.on("connection", socket => { sockets.add(socket); socket.on("close", () => sockets.delete(socket)); });
+    const websocket = new WebSocketServer({ noServer: true });
+    server.on("upgrade", (request, socket, head) => {
+        websocket.handleUpgrade(request, socket, head, client => {
+            const target = windowsMetroURL(`http://127.0.0.1${request.url}`, port, options);
+            target.protocol = options.https ? "wss:" : "ws:";
+            const remote = new WebSocket(target, ca ? { ca } : {});
+            remotes.add(remote);
+            let pending = [], bytes = 0;
+            remote.on("open", () => {
+                for (const message of pending)
+                    remote.send(message.data, { binary: message.binary });
+                pending = [];
+                bytes = 0;
+            });
+            remote.on("message", (data, binary) => { if (client.readyState === WebSocket.OPEN)
+                client.send(data, { binary }); });
+            remote.on("close", () => { remotes.delete(remote); client.close(); });
+            remote.on("error", () => client.close(1011, "Expo Metro WebSocket connection failed"));
+            client.on("message", (data, binary) => {
+                if (remote.readyState === WebSocket.OPEN)
+                    remote.send(data, { binary });
+                else {
+                    bytes += Array.isArray(data) ? data.reduce((sum, part) => sum + part.length, 0) : data.byteLength;
+                    if (bytes > 1024 * 1024) {
+                        remote.terminate();
+                        client.close(1009, "Metro connection queue exceeded");
+                    }
+                    else
+                        pending.push({ data, binary });
+                }
+            });
+            client.on("error", () => remote.terminate());
+            client.on("close", () => { remote.terminate(); pending = []; });
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => { server.off("error", reject); resolve(); });
+    });
+    server.unref();
+    return { port: server.address().port, stop(_force = true) {
+            for (const remote of remotes)
+                remote.terminate();
+            for (const client of websocket.clients)
+                client.terminate();
+            for (const socket of sockets)
+                socket.destroy();
+            websocket.close();
+            server.close();
+        } };
+}
+const connections = new Map();
+export async function windowsMetroPort(root, port, options) {
+    const key = JSON.stringify([port, options.https ?? false, options.dev ?? true, options.minify ?? false]);
+    const previous = connections.get(root);
+    if (previous?.key === key)
+        return previous.server.port;
+    previous?.server.stop(true);
+    connections.delete(root);
+    if (!options.https && options.dev !== false && !options.minify)
+        return port;
+    const server = await startWindowsMetro(port, options);
+    connections.set(root, { key, server });
+    return server.port;
+}
+export function stopWindowsMetro(root) { connections.get(root)?.server.stop(true); connections.delete(root); }

package/vendor/node_modules/@legendapp/spark-cli/dist/windows.js

@@ -0,0 +1,141 @@
+import { which } from "./process.js";
+import { prepareWindowsGeometry } from "./windows-geometry.js";
+import { copyHelpers } from "./helpers.js";
+import { registerWindowsAssociations } from "./windows-associations.js";
+import { checkExpoDesktopNode } from "./expo-node.js";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, renameSync, rmSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { run } from "./commands.js";
+import { prepareConfig, nativePackages, runtimeFor, stateFile, readJson, writeJson, validateBuildModules, goConfigurationIssues, readAppConfig } from "./project.js";
+// Windows .cmd shims are shell programs; run the package's actual JS entry.
+export function nodeCommand(root, name, bin, args = []) {
+    const req = createRequire(path.join(root, "package.json"));
+    const file = req.resolve(`${name}/package.json`), pkg = readJson(file);
+    return ["node", path.resolve(path.dirname(file), typeof pkg.bin === "string" ? pkg.bin : pkg.bin[bin]), ...args];
+}
+export async function preserveWindowsBuildOutputs(root, prepare) {
+    const windows = path.join(root, "windows");
+    const outputs = [];
+    function visit(directory) {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            if (entry.isDirectory() && entry.name !== "node_modules") {
+                const file = path.join(directory, entry.name);
+                if (/^(arm64|x64|x86|win32)$/i.test(entry.name))
+                    outputs.push(file);
+                else
+                    visit(file);
+            }
+        }
+    }
+    if (existsSync(windows))
+        visit(windows);
+    const moved = [];
+    let temporary;
+    try {
+        if (outputs.length) {
+            const parent = stateFile(root, "prebuild-cache");
+            mkdirSync(parent, { recursive: true });
+            temporary = mkdtempSync(path.join(parent, "windows-"));
+            for (const source of outputs) {
+                const saved = path.join(temporary, String(moved.length));
+                renameSync(source, saved);
+                moved.push({ source, saved });
+            }
+        }
+        // Expo beta scans existing output folders as templates, including .Xaml directories.
+        await prepare();
+    }
+    finally {
+        for (const { source, saved } of moved)
+            renameSync(saved, source);
+        if (temporary)
+            rmSync(temporary, { recursive: true });
+    }
+}
+export async function prepareWindows(root, mode) {
+    await checkExpoDesktopNode(root);
+    prepareConfig(root);
+    prepareWindowsGeometry(root);
+    const packages = nativePackages(root);
+    validateBuildModules(mode, packages);
+    if (mode === "go") {
+        const issues = goConfigurationIssues(readAppConfig(root));
+        if (issues.length)
+            throw new Error(`Build the Spark Runner from a generic SDK starter: ${issues.join("; ")}`);
+    }
+    const runtime = runtimeFor(root, packages, mode);
+    writeJson(stateFile(root, "windows-build-input.json"), runtime);
+    writeJson(stateFile(root, "native-selection.json"), { included: packages.map(pkg => ({ name: pkg.name, root: pkg.root })), excluded: [] });
+    const manifest = readFileSync(path.join(root, "package.json"), "utf8");
+    try {
+        await preserveWindowsBuildOutputs(root, async () => {
+            await run(root, nodeCommand(root, "expo-desktop", "expo-desktop", ["prebuild", "--platform", "windows", "--template", "expo-desktop-template-bare-minimum@54.81.1-beta.6", "--no-install"]), { env: { CI: "1" }, capture: true });
+        });
+        // The beta template expands all-platform dependencies. Keep the consumer's installed graph.
+    }
+    finally {
+        writeFileSync(path.join(root, "package.json"), manifest);
+    }
+    return runtime;
+}
+export async function buildWindows(root, mode, force) {
+    if (mode !== "go" && mode !== "dev")
+        throw new Error("Windows currently supports Spark Runner runtimes and development builds. Use spark build --dev; production builds and packaging are not implemented.");
+    if (process.platform !== "win32")
+        throw new Error("Windows native builds require Windows x64 or ARM64. Project generation and Metro bundle checks can run on macOS.");
+    for (const tool of ["node", "pwsh.exe", "dotnet.exe"])
+        if (!which(tool))
+            throw new Error(`Missing ${tool}. See docs/windows-slice.md for the Windows native prerequisites.`);
+    const expected = runtimeFor(root, nativePackages(root), mode);
+    const record = stateFile(root, `${mode}-build.json`);
+    if (!force && existsSync(record)) {
+        const old = readJson(record);
+        if (old.runtime.arch === expected.arch && old.runtime.fingerprint === expected.fingerprint && existsSync(path.join(old.app, "MyApp.exe"))) {
+            if (mode === "dev")
+                await registerWindowsAssociations(root, old.app);
+            return old;
+        }
+    }
+    const runtime = await prepareWindows(root, mode);
+    const target = runtime.arch === "arm64" ? "ARM64" : "x64";
+    // RNW invokes x64 MSBuild even on ARM64 hosts. Match its compiler host to avoid
+    // falling back to x86 and exhausting address space while loading large PCHs.
+    await run(root, nodeCommand(root, "react-native", "react-native", ["run-windows", "--arch", target, "--msbuildprops", "PreferredToolArchitecture=x64", "--no-packager", "--no-launch", "--no-deploy", "--no-telemetry", "--logging", "--buildLogDirectory", stateFile(root, "logs/msbuild")]), { capture: true });
+    if (runtimeFor(root, nativePackages(root), mode).fingerprint !== runtime.fingerprint)
+        throw new Error("Native inputs changed during the build. Retry; no Windows runtime was registered.");
+    const products = [];
+    function visit(dir) {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const file = path.join(dir, entry.name);
+            if (entry.isDirectory() && !["Generated Files", "node_modules", "packages"].includes(entry.name))
+                visit(file);
+            else if (entry.isFile() && isWindowsDebugProduct(path.relative(path.join(root, "windows"), file), runtime.arch))
+                products.push(file);
+        }
+    }
+    visit(path.join(root, "windows"));
+    if (products.length !== 1)
+        throw new Error(`Expected one Windows Debug/${target} MyApp.exe; found ${products.length}. Inspect .spark/logs.`);
+    const app = stateFile(root, `products/${runtime.arch}/${mode}/SparkWindows`), pending = `${app}.pending`;
+    rmSync(pending, { recursive: true, force: true });
+    mkdirSync(path.dirname(pending), { recursive: true });
+    cpSync(path.dirname(products[0]), pending, { recursive: true });
+    copyHelpers(root, pending, readAppConfig(root).expo.extra?.spark?.helpers, "windows");
+    writeJson(path.join(pending, "spark-runtime.json"), runtime);
+    rmSync(app, { recursive: true, force: true });
+    // Copy only after a complete build, keeping Go and dev products independent.
+    const { renameSync } = await import("node:fs");
+    renameSync(pending, app);
+    const result = { app, runtime };
+    writeJson(record, result);
+    if (mode === "dev")
+        await registerWindowsAssociations(root, app);
+    console.log(`Built ${app}`);
+    return result;
+}
+export function isWindowsDebugProduct(relativeFile, arch) {
+    const parts = relativeFile.toLowerCase().split(/[\\/]/);
+    const architectureIndex = parts.indexOf(arch);
+    return parts.at(-1) === "myapp.exe" && architectureIndex >= 0 && parts.indexOf("debug", architectureIndex + 1) > architectureIndex;
+}

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

@@ -0,0 +1,22 @@
+{
+  "name": "@legendapp/spark-cli",
+  "version": "0.0.1-next.2",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "engines": {
+    "node": ">=24.19.0"
+  },
+  "dependencies": {
+    "@legendapp/spark-desktop-config": "0.0.1-next.2",
+    "ws": "8.18.3",
+    "expo-desktop": "1.0.0-beta.6",
+    "npm": "11.11.0",
+    "typescript": "5.9.3",
+    "cross-spawn": "7.0.6"
+  },
+  "private": true
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/blank-typescript/App.tsx

@@ -0,0 +1,29 @@
+import React, { useEffect, useState } from "react";
+import { Button, StyleSheet, Text, View } from "react-native";
+import { openFileDialog } from "@legendapp/spark/dialogs";
+import { configureMenus, clearMenus, addNativeMenuActionListener } from "@legendapp/spark/menus";
+
+const menus = [{ id: "hello", title: "Hello", items: [{ id: "greet", title: "Say Hello" }] }];
+export default function App({ runtime }: { runtime?: { mode: string } }) {
+  const [message, setMessage] = useState("Ready");
+  useEffect(() => {
+    configureMenus("hello-world", menus);
+    const subscription = addNativeMenuActionListener(action => {
+      if (action.ownerId === "hello-world" && action.itemId === "greet") setMessage("Hello from the native menu");
+    });
+    return () => { subscription.remove(); clearMenus("hello-world"); };
+  }, []);
+  async function chooseFile() {
+    try {
+      const files = await openFileDialog({ title: "Choose a file", allowsMultipleSelection: false });
+      setMessage(files?.join(", ") || "Dialog cancelled");
+    } catch (error) { setMessage(String(error)); }
+  }
+  return <View style={styles.root}>
+    <Text style={styles.title}>Hello, Legend Spark</Text>
+    <Text style={styles.text}>Runtime: {runtime?.mode ?? "unknown"}</Text>
+    <Button title="Choose a file" onPress={chooseFile} />
+    <Text style={styles.text} accessible accessibilityLabel={message}>{message}</Text>
+  </View>;
+}
+const styles = StyleSheet.create({ root: { flex: 1, alignItems: "center", justifyContent: "center", gap: 16, backgroundColor: "#f5f5f7" }, text: { color: "#18181b" }, title: { fontSize: 32, fontWeight: "600", color: "#18181b" } });

package/vendor/node_modules/@legendapp/spark-cli/templates/blank-typescript/app.json

@@ -0,0 +1,11 @@
+{
+  "expo": {
+    "name": "HelloWorld",
+    "slug": "helloworld",
+    "version": "0.0.1",
+    "platforms": [
+      "macos"
+    ],
+    "icon": "./assets/icon.png"
+  }
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/blank-typescript/desktop.config.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "./node_modules/@legendapp/spark/schema.json",
+  "name": "HelloWorld",
+  "version": "0.0.1",
+  "window": {
+    "width": 1000,
+    "height": 700,
+    "restoreFrame": true
+  },
+  "macos": {
+    "bundleIdentifier": "so.legend.spark.prototype.helloworld"
+  },
+  "platforms": [
+    "macos"
+  ],
+  "expo": {
+    "icon": "./assets/icon.png"
+  }
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/blank-typescript/gitignore

@@ -0,0 +1,8 @@
+node_modules/
+.threaded-runtime/
+.spark/
+macos/
+dist/
+app.json
+windows/
+.expo/

package/vendor/node_modules/@legendapp/spark-cli/templates/blank-typescript/index.ts

@@ -0,0 +1,5 @@
+require("@legendapp/spark/runtime-entry");
+if (!(globalThis as any).__THREADED_RUNTIME_ENV__) {
+  const { registerRootComponent } = require("expo");
+  registerRootComponent(require("./App").default);
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/blank-typescript/metro.config.js

@@ -0,0 +1,3 @@
+const { makeMetroConfig } = require("expo-desktop-metro-config");
+const { withDesktop } = require("@legendapp/spark/metro");
+module.exports = withDesktop(makeMetroConfig(__dirname));

package/vendor/node_modules/@legendapp/spark-cli/templates/blank-typescript/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "spark-template-blank-typescript",
+  "version": "0.0.1",
+  "private": true,
+  "main": "index.ts",
+  "scripts": {
+    "start": "spark dev",
+    "macos": "spark dev",
+    "dev": "spark dev",
+    "build": "spark build",
+    "package": "spark package",
+    "doctor": "spark doctor",
+    "postinstall": "node node_modules/@legendapp/spark/init-template.cjs"
+  },
+  "dependencies": {
+    "@legendapp/spark": "0.0.1-next.2",
+    "expo": "54.0.37",
+    "expo-desktop": "1.0.0-beta.6",
+    "expo-desktop-prebuild-config": "1.1.0-beta.1",
+    "expo-desktop-config-plugins": "1.2.0-beta.1",
+    "expo-desktop-metro-config": "54.81.0-beta.3",
+    "expo-desktop-template-bare-minimum": "54.81.1-beta.6",
+    "react": "19.1.4",
+    "react-native": "0.81.6",
+    "react-native-macos": "0.81.7",
+    "@react-native-community/cli": "20.1.3",
+    "typescript": "5.9.3",
+    "@types/react": "19.1.10",
+    "@react-native-runtimes/core": "0.1.0-alpha.2"
+  },
+  "overrides": {
+    "@expo/cli": "54.0.27",
+    "react-native-nitro-modules": "0.35.7",
+    "react-native-webview": "16.0.0",
+    "@op-engineering/op-sqlite": "18.2.1",
+    "expo-asset": "12.0.13",
+    "expo-constants": "18.0.14",
+    "expo-file-system": "19.0.24",
+    "expo-font": "14.0.12",
+    "expo-keep-awake": "15.0.8",
+    "expo-modules-core": "3.0.30",
+    "expo-desktop-modules-core": "54.0.14-beta.0",
+    "expo-desktop-stubs": "54.0.14-beta.0",
+    "react": "19.1.4",
+    "react-native": "0.81.6"
+  },
+  "expo": {
+    "install": {
+      "exclude": [
+        "react",
+        "react-native"
+      ]
+    }
+  }
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/blank-typescript/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "strict": true
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx"
+  ]
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/diff-lite/App.tsx

@@ -0,0 +1,34 @@
+import { useMemo, useState } from "react";
+import { FlatList, SafeAreaView, StyleSheet, Text, View } from "react-native";
+import { Button } from "@legendapp/spark/ui";
+import { io } from "./shared/io";
+import { Lifecycle } from "./shared/Lifecycle";
+import { compare } from "./compare";
+import { Git } from "./Git";
+const clean = () => false, flush = async () => true;
+export default function App({ windowId = "main" }: { windowId?: string }) {
+  const [left, setLeft] = useState({ name: "Original", text: "A shared application\nNative platform behavior\n" });
+  const [right, setRight] = useState({ name: "Changed", text: "A shared application\nNative platform behavior\nOne codebase\n" });
+  const [error, setError] = useState<string | null>(null);
+  const [patch, setPatch] = useState<string | null>(null);
+  const [busy, setBusy] = useState(false);
+  const commands = useMemo(() => [{ id: "open", title: "Open original…", key: "O", run: () => open("left") }], []);
+  async function open(side: "left" | "right") {
+    setBusy(true); setError(null);
+    try { const file = await io.open(); if (file) { if (file.text.length > 200_000) throw new Error("Choose a file smaller than 200,000 characters."); (side === "left" ? setLeft : setRight)({ name: file.file.name, text: file.text }); setPatch(null); } }
+    catch (error) { setError(String(error)); } finally { setBusy(false); }
+  }
+  const comparison = useMemo(() => { try { return { rows: compare(left.text, right.text), error: null }; } catch (error) { return { rows: [], error: String(error) }; } }, [left.text, right.text]);
+  const patchLines = useMemo(() => patch?.split("\n"), [patch]);
+  return <SafeAreaView style={styles.root}>
+    <Lifecycle title="Diff" windowId={windowId} flush={flush} dirty={clean} commands={commands} onError={setError} />
+    <Text style={styles.title}>Diff</Text><Text>{left.name} → {right.name}</Text>
+    <View style={styles.toolbar}><Button disabled={busy} onPress={() => { void open("left"); }}>Open original</Button><Button disabled={busy} onPress={() => { void open("right"); }}>Open changed</Button><Button onPress={() => { setLeft(right); setRight(left); setPatch(null); }}>Swap files</Button><Git onResult={setPatch} onError={setError} /></View>
+    <Text>− Removed · + Added · unchanged lines have no marker</Text>
+    {error || comparison.error ? <Text accessibilityRole="alert" style={styles.error}>{error ?? comparison.error}</Text> : null}
+    {patchLines ? <FlatList data={patchLines} keyExtractor={(_, index) => String(index)} renderItem={({ item }) => <Text selectable style={styles.code}>{item || " "}</Text>} /> : <FlatList data={comparison.rows} keyExtractor={(_, index) => String(index)} renderItem={({ item }) => <View style={[styles.line, item.kind === "added" && styles.added, item.kind === "removed" && styles.removed]}>
+      <Text style={styles.number}>{item.left ?? ""}</Text><Text style={styles.number}>{item.right ?? ""}</Text><Text selectable style={styles.code}>{item.kind === "added" ? "+ " : item.kind === "removed" ? "− " : "  "}{item.text || " "}</Text>
+    </View>} />}
+  </SafeAreaView>;
+}
+const styles = StyleSheet.create({ root: { flex: 1, padding: 20, gap: 12, backgroundColor: "#faf9f6" }, title: { fontSize: 28, fontWeight: "600", color: "#222" }, toolbar: { flexDirection: "row", flexWrap: "wrap", gap: 8 }, line: { flexDirection: "row", paddingVertical: 3 }, number: { width: 36, color: "#555", textAlign: "right", paddingRight: 8, fontSize: 12 }, code: { flex: 1, flexShrink: 1, fontFamily: "monospace", fontSize: 13, color: "#222" }, added: { backgroundColor: "#ddf4df" }, removed: { backgroundColor: "#f9dddd" }, error: { color: "#a32020" } });

package/vendor/node_modules/@legendapp/spark-cli/templates/diff-lite/Git.macos.tsx

@@ -0,0 +1,13 @@
+import { useState } from "react";
+import { Button } from "@legendapp/spark/ui";
+import { openFileDialog } from "@legendapp/spark/dialogs";
+import { runCommand } from "@legendapp/spark/processes";
+export function Git({ onResult, onError }: { onResult(text: string): void; onError(message: string): void }) {
+  const [busy, setBusy] = useState(false);
+  return <Button disabled={busy} onPress={() => { setBusy(true); void (async () => {
+    const paths = await openFileDialog({ canChooseDirectories: true, canChooseFiles: false }); if (!paths?.[0]) return;
+    const result = await runCommand({ executable: "/usr/bin/git", args: ["--no-pager", "diff", "--no-ext-diff", "--no-textconv", "--", "."], cwd: paths[0], timeoutMs: 10_000 });
+    if (result.timedOut || result.outputTruncated || result.exitCode !== 0) throw new Error(result.stderr || "Git comparison failed or exceeded its output limit");
+    onResult(result.stdout || "No unstaged changes.");
+  })().catch(error => onError(String(error))).finally(() => setBusy(false)); }}>{busy ? "Reading Git…" : "Open Git changes"}</Button>;
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/diff-lite/Git.tsx

@@ -0,0 +1 @@
+export function Git(_props: { onResult(text: string): void; onError(message: string): void }) { return null; }

package/vendor/node_modules/@legendapp/spark-cli/templates/diff-lite/compare.ts

@@ -0,0 +1,12 @@
+import { diffLines } from "diff";
+export type DiffLine = { kind: "same" | "added" | "removed"; text: string; left: number | null; right: number | null };
+export function compare(left: string, right: string): DiffLine[] {
+  if (left.length + right.length > 400_000) throw new Error("Choose text files smaller than 200,000 characters each for this example.");
+  const changes = diffLines(left, right, { timeout: 300 });
+  if (!changes) throw new Error("These files take too long to compare. Try a smaller selection.");
+  let a = 0, b = 0;
+  return changes.flatMap(change => {
+    const lines = change.value.split("\n"); if (lines.at(-1) === "") lines.pop();
+    return lines.map(text => ({ kind: change.added ? "added" as const : change.removed ? "removed" as const : "same" as const, text, left: change.added ? null : ++a, right: change.removed ? null : ++b }));
+  });
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/App.tsx

@@ -0,0 +1,34 @@
+import { useState } from "react";
+import { Platform, SafeAreaView, StyleSheet, Text, TextInput, View } from "react-native";
+import { Button } from "@legendapp/spark/ui";
+import { Integration } from "./Integration";
+import { sessionFor } from "./sessions";
+import { useDocument } from "./useDocument";
+export default function App({ windowId = "main", windowProps }: { windowId?: string; windowProps?: { documentId?: string } }) {
+  const documentId = windowProps?.documentId ?? "main";
+  const [session] = useState(() => sessionFor(documentId));
+  const state = useDocument(session);
+  const [guardsReady, setGuardsReady] = useState(Platform.OS !== "macos");
+  const copy = ["ios", "android", "web"].includes(Platform.OS);
+  return <SafeAreaView style={styles.root}>
+    <View style={styles.header}>
+      <Text style={styles.title}>{state.file.name}{session.dirty ? " •" : ""}</Text>
+      <Text>{copy ? "Open imports a copy. Save exports your text." : state.file.location ?? "Choose a location when saving."}</Text>
+      <View style={styles.toolbar}>
+        <Button disabled={state.busy || !guardsReady} onPress={() => { void session.newDocument(); }}>New</Button>
+        <Button disabled={state.busy || !guardsReady} onPress={() => { void session.open(); }}>Open</Button>
+        <Button disabled={state.busy || !guardsReady} onPress={() => { void session.save(); }}>{copy ? "Save a copy" : "Save"}</Button>
+        {!copy ? <Button disabled={state.busy || !guardsReady} onPress={() => { void session.save(true); }}>Save As</Button> : null}
+      </View>
+      <Integration session={session} windowId={windowId} documentId={documentId} onReady={setGuardsReady} />
+      {state.error ? <Text accessibilityRole="alert" style={styles.error}>{state.error}</Text> : null}
+    </View>
+    <TextInput testID="document-body" accessibilityLabel="Document text" multiline editable={guardsReady} value={state.text} onChangeText={session.edit} textAlignVertical="top" style={styles.editor} autoCapitalize="none" autoCorrect={false} />
+    <Text style={styles.status}>{state.busy ? "Working…" : session.dirty ? "Unsaved changes" : "Saved"} · {state.text.length} characters</Text>
+  </SafeAreaView>;
+}
+const styles = StyleSheet.create({
+  root: { flex: 1, backgroundColor: "#faf9f6" }, header: { padding: 20, gap: 10 }, title: { fontSize: 24, fontWeight: "600", color: "#222" },
+  toolbar: { flexDirection: "row", flexWrap: "wrap", gap: 8 }, editor: { flex: 1, marginHorizontal: 20, padding: 16, borderWidth: 1, borderColor: "#bbb", borderRadius: 6, backgroundColor: "white", color: "#222", fontSize: 16 },
+  error: { color: "#ad2020" }, status: { padding: 16, color: "#555" },
+});

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/Integration.macos.tsx

@@ -0,0 +1,57 @@
+import { useEffect, useState } from "react";
+import { Text } from "react-native";
+import { Button } from "@legendapp/spark/ui";
+import { beforeWindowClose, openWindow, setWindowTitle, onWindowEvent } from "@legendapp/spark/windows";
+import { beforeQuit } from "@legendapp/spark/app";
+import { configureMenus, clearMenus, addNativeMenuActionListener } from "@legendapp/spark/menus";
+import { registerShortcut } from "@legendapp/spark/shortcuts";
+import { onOpen } from "@legendapp/spark/links";
+import { readTextFile } from "@legendapp/spark/dialogs";
+import { sessions } from "./sessions";
+import type { DocumentSession } from "./document";
+let nextWindow = 0;
+export function Integration({ session, windowId, documentId, onReady }: { session: DocumentSession; windowId: string; documentId: string; onReady: (ready: boolean) => void }) {
+  const [error, setError] = useState<string | null>(null);
+  useEffect(() => {
+    let removed = false;
+    const cleanups: (() => void | Promise<void>)[] = [];
+    const retain = async (registration: Promise<{ remove(): void | Promise<void> }>) => {
+      const subscription = await registration;
+      if (removed) await subscription.remove(); else cleanups.push(() => subscription.remove());
+    };
+    const owner = `editor-${windowId}`;
+    const actions: Record<string, () => unknown> = { new: () => session.newDocument(), open: () => session.open(), save: () => session.save(), saveAs: () => session.save(true) };
+    const menus = () => configureMenus(owner, [{ id: "file", title: "File", items: [
+      { id: "new", title: "New" }, { id: "open", title: "Open…" }, { id: "save", title: "Save" }, { id: "saveAs", title: "Save As…" },
+    ] }]);
+    menus(); cleanups.push(() => clearMenus(owner));
+    const menu = addNativeMenuActionListener(event => { if (event.ownerId === owner) actions[event.itemId]?.(); });
+    cleanups.push(() => menu.remove());
+    const focus = onWindowEvent(event => { if (event.type === "focus" && event.windowId === windowId) menus(); });
+    cleanups.push(() => focus.remove());
+    const title = () => { const state = session.getSnapshot(); void setWindowTitle(windowId, `${state.file.name}${session.dirty ? " •" : ""}`).catch(e => setError(String(e))); };
+    title(); cleanups.push(session.subscribe(title));
+    void (async () => {
+      await retain(beforeWindowClose(windowId, session.canClose));
+      for (const [key, action] of Object.entries({ "Command+N": actions.new!, "Command+O": actions.open!, "Command+S": actions.save!, "Command+Shift+S": actions.saveAs! })) {
+        await retain(registerShortcut(key, () => { action(); }, { windowId }));
+      }
+      if (windowId === "main") {
+        await retain(beforeQuit(async () => { for (const document of sessions.values()) if (!await document.canClose()) return false; return true; }));
+        await retain(onOpen(event => {
+          if (event.type !== "openFile") return;
+          const match = /^file:\/\/(?:localhost)?(\/.*)$/.exec(event.url);
+          if (!match) { setError("Unsupported file URL"); return; }
+          const location = decodeURIComponent(match[1]!);
+          void readTextFile(location).then(text => session.load({ location, name: location.split("/").pop()! }, text)).catch(e => setError(String(e)));
+        }));
+      }
+      if (!removed) onReady(true);
+    })().catch(e => setError(String(e)));
+    return () => { removed = true; for (const cleanup of cleanups.reverse()) void Promise.resolve().then(cleanup).catch(console.error); };
+  }, [session, windowId, onReady]);
+  return <>
+    <Button onPress={() => { void openWindow({ id: `document-${++nextWindow}`, title: session.getSnapshot().file.name, width: 800, height: 600, props: { documentId } }).catch(e => setError(String(e))); }}>Open another view</Button>
+    {error ? <Text accessibilityRole="alert">{error}</Text> : null}
+  </>;
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/Integration.tsx

@@ -0,0 +1,13 @@
+import { useEffect } from "react";
+import { BackHandler } from "react-native";
+import type { DocumentSession } from "./document";
+export function Integration({ session }: { session: DocumentSession; windowId: string; documentId: string; onReady: (ready: boolean) => void }) {
+  useEffect(() => {
+    const back = BackHandler.addEventListener("hardwareBackPress", () => {
+      if (!session.dirty) return false;
+      void session.canClose().then(allow => { if (allow) BackHandler.exitApp(); }); return true;
+    });
+    return () => back.remove();
+  }, [session]);
+  return null;
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/Integration.web.tsx

@@ -0,0 +1,14 @@
+import { useEffect } from "react";
+import type { DocumentSession } from "./document";
+export function Integration({ session }: { session: DocumentSession; windowId: string; documentId: string; onReady: (ready: boolean) => void }) {
+  useEffect(() => {
+    const unload = (event: BeforeUnloadEvent) => { if (session.dirty) { event.preventDefault(); event.returnValue = ""; } };
+    const key = (event: KeyboardEvent) => {
+      if (!(event.metaKey || event.ctrlKey) || !["s", "o"].includes(event.key.toLowerCase())) return;
+      event.preventDefault(); if (event.key.toLowerCase() === "s") void session.save(event.shiftKey); else void session.open();
+    };
+    window.addEventListener("beforeunload", unload); window.addEventListener("keydown", key);
+    return () => { window.removeEventListener("beforeunload", unload); window.removeEventListener("keydown", key); };
+  }, [session]);
+  return null;
+}