@legendapp/spark 0.0.1-next.2

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/Integration.windows.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({ "Control+N": actions.new!, "Control+O": actions.open!, "Control+S": actions.save!, "Control+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]!).replace(/^\/([A-Za-z]:)/, "$1").replace(/\//g, "\\");
+          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/document.ts

@@ -0,0 +1,58 @@
+export type FileReference = { name: string; location?: string; handle?: unknown };
+export type DocumentState = { text: string; savedText: string; file: FileReference; busy: boolean; error: string | null; revision: number };
+export type DocumentIO = {
+  open(): Promise<{ file: FileReference; text: string } | null>;
+  save(file: FileReference, text: string, expected: string, saveAs: boolean): Promise<FileReference | null>;
+  confirmDiscard(name: string): Promise<"save" | "discard" | "cancel">;
+};
+/** One document model is shared by its windows; I/O always works on a snapshot. */
+export class DocumentSession {
+  private state: DocumentState = { text: "", savedText: "", file: { name: "Untitled.txt" }, busy: false, error: null, revision: 0 };
+  private listeners = new Set<() => void>();
+  private active = false;
+  constructor(readonly io: DocumentIO) {}
+  getSnapshot = () => this.state;
+  subscribe = (listener: () => void) => { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; };
+  private update(patch: Partial<DocumentState>) { this.state = { ...this.state, ...patch }; for (const listener of this.listeners) listener(); }
+  edit = (text: string) => { if (text !== this.state.text) this.update({ text, revision: this.state.revision + 1 }); };
+  get dirty() { return this.state.text !== this.state.savedText; }
+  private async operation(action: () => Promise<boolean>) {
+    if (this.active) return false;
+    this.active = true; this.update({ busy: true, error: null });
+    try { return await action(); }
+    catch (error) { this.update({ error: error instanceof Error ? error.message : String(error) }); return false; }
+    finally { this.active = false; this.update({ busy: false }); }
+  }
+  private async saveSnapshot(saveAs: boolean) {
+    const snapshot = this.state;
+    const file = await this.io.save(snapshot.file, snapshot.text, snapshot.savedText, saveAs);
+    if (!file) return false;
+    // Edits typed during an asynchronous save remain dirty.
+    this.update({ file, savedText: snapshot.text }); return true;
+  }
+  save = (saveAs = false) => this.operation(() => this.saveSnapshot(saveAs));
+  private async mayReplace() {
+    if (!this.dirty) return true;
+    const revision = this.state.revision;
+    const answer = await this.io.confirmDiscard(this.state.file.name);
+    if (answer === "cancel") return false;
+    if (answer === "save") return await this.saveSnapshot(false) && !this.dirty;
+    return revision === this.state.revision;
+  }
+  canClose = () => this.operation(() => this.mayReplace());
+  newDocument = () => this.operation(async () => {
+    if (!await this.mayReplace()) return false;
+    this.update({ text: "", savedText: "", file: { name: "Untitled.txt" }, revision: this.state.revision + 1 }); return true;
+  });
+  open = () => this.operation(async () => {
+    if (!await this.mayReplace()) return false;
+    const revision = this.state.revision;
+    const loaded = await this.io.open();
+    if (!loaded || revision !== this.state.revision) return false;
+    this.update({ file: loaded.file, text: loaded.text, savedText: loaded.text, revision: revision + 1 }); return true;
+  });
+  load = (file: FileReference, text: string) => this.operation(async () => {
+    if (!await this.mayReplace()) return false;
+    this.update({ file, text, savedText: text, revision: this.state.revision + 1 }); return true;
+  });
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/io.desktop.ts

@@ -0,0 +1,24 @@
+import { openFileDialog, saveFileDialog, readTextFile, writeTextFile, writeTextFileIfUnchanged } from "@legendapp/spark/dialogs";
+import { Alert } from "react-native";
+import type { DocumentIO } from "./document";
+export const io: DocumentIO = {
+  async open() {
+    const paths = await openFileDialog({ allowedFileTypes: ["txt", "md", "json"], allowsMultipleSelection: false });
+    if (!paths?.[0]) return null;
+    const location = paths[0];
+    return { file: { location, name: location.split(/[\\/]/).pop()! }, text: await readTextFile(location) };
+  },
+  async save(file, text, expected, saveAs) {
+    const location = saveAs || !file.location ? await saveFileDialog({ defaultName: file.name, allowedFileTypes: ["txt", "md", "json"] }) : file.location;
+    if (!location) return null;
+    if (location === file.location) {
+      if (!await writeTextFileIfUnchanged(location, expected, text)) throw new Error("The file changed outside the editor. Use Save As to keep your edits in another file.");
+    } else await writeTextFile(location, text);
+    return { location, name: location.split(/[\\/]/).pop()! };
+  },
+  confirmDiscard: name => new Promise(resolve => Alert.alert("Unsaved changes", `Save changes to ${name}?`, [
+    { text: "Cancel", style: "cancel", onPress: () => resolve("cancel") },
+    { text: "Discard", style: "destructive", onPress: () => resolve("discard") },
+    { text: "Save", onPress: () => resolve("save") },
+  ], { cancelable: false })),
+};

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/io.macos.ts

@@ -0,0 +1,7 @@
+import { io as desktop } from "./io.desktop";
+import { showMessage } from "@legendapp/spark/message-dialog";
+import type { DocumentIO } from "./document";
+export const io: DocumentIO = { ...desktop, async confirmDiscard(name) {
+  const { button } = await showMessage({ title: "Unsaved changes", message: `Save changes to ${name}?`, buttons: ["Cancel", "Discard", "Save"], cancelButton: 0, defaultButton: 2 });
+  return (["cancel", "discard", "save"] as const)[button] ?? "cancel";
+} };

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/io.ts

@@ -0,0 +1,31 @@
+import * as DocumentPicker from "expo-document-picker";
+import * as FileSystem from "expo-file-system/legacy";
+import * as Sharing from "expo-sharing";
+import { Alert } from "react-native";
+import type { DocumentIO } from "./document";
+export const io: DocumentIO = {
+  async open() {
+    const result = await DocumentPicker.getDocumentAsync({ type: ["text/*", "application/json"], copyToCacheDirectory: true });
+    if (result.canceled) return null;
+    const asset = result.assets[0]!;
+    if ((asset.size ?? 0) > 8 * 1024 * 1024) throw new Error("Choose a text file smaller than 8 MB");
+    // The picker returns an imported copy, not permission to overwrite the source.
+    return { file: { name: asset.name }, text: await FileSystem.readAsStringAsync(asset.uri) };
+  },
+  async save(file, text) {
+    if (!await Sharing.isAvailableAsync()) throw new Error("File sharing is unavailable on this device");
+    const directory = FileSystem.documentDirectory;
+    if (!directory) throw new Error("Document storage is unavailable");
+    const name = file.name.replace(/[^a-zA-Z0-9._-]/g, "_") || "Untitled.txt";
+    const location = `${directory}spark-${name}`;
+    await FileSystem.writeAsStringAsync(location, text);
+    await Sharing.shareAsync(location, { mimeType: "text/plain", UTI: "public.plain-text" });
+    // Save commits the app's durable copy, regardless of share-sheet dismissal.
+    return { name: file.name, location };
+  },
+  confirmDiscard: name => new Promise(resolve => Alert.alert("Unsaved changes", `Save a copy of ${name}?`, [
+    { text: "Cancel", style: "cancel", onPress: () => resolve("cancel") },
+    { text: "Discard", style: "destructive", onPress: () => resolve("discard") },
+    { text: "Save", onPress: () => resolve("save") },
+  ], { cancelable: false })),
+};

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/io.web.ts

@@ -0,0 +1,21 @@
+import type { DocumentIO } from "./document";
+export const io: DocumentIO = {
+  open: () => new Promise((resolve, reject) => {
+    const input = document.createElement("input"); input.type = "file"; input.accept = ".txt,.md,.json,text/plain";
+    input.oncancel = () => resolve(null);
+    input.onchange = () => {
+      const file = input.files?.[0];
+      if (!file) { resolve(null); return; }
+      if (file.size > 8 * 1024 * 1024) { reject(new Error("Choose a text file smaller than 8 MB")); return; }
+      void file.text().then(text => resolve({ file: { name: file.name }, text }), reject);
+    };
+    input.click();
+  }),
+  async save(file, text) {
+    const url = URL.createObjectURL(new Blob([text], { type: "text/plain;charset=utf-8" }));
+    const anchor = document.createElement("a"); anchor.href = url; anchor.download = file.name; anchor.click();
+    setTimeout(() => URL.revokeObjectURL(url), 30_000);
+    return { name: file.name };
+  },
+  async confirmDiscard(name) { return window.confirm(`Discard unsaved changes to ${name}? Choose Cancel to return and save.`) ? "discard" : "cancel"; },
+};

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/io.windows.ts

@@ -0,0 +1 @@
+export { io } from "./io.desktop";

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/sessions.ts

@@ -0,0 +1,8 @@
+import { DocumentSession } from "./document";
+import { io } from "./io";
+// Secondary macOS roots share this JS heap and therefore the same document data.
+export const sessions = new Map<string, DocumentSession>();
+export function sessionFor(id: string) {
+  if (!sessions.has(id)) sessions.set(id, new DocumentSession(io));
+  return sessions.get(id)!;
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/document-editor/useDocument.ts

@@ -0,0 +1,6 @@
+import { useSyncExternalStore } from "react";
+import type { DocumentSession } from "./document";
+/** React adapter for the document model shared by native window roots. */
+export function useDocument(session: DocumentSession) {
+  return useSyncExternalStore(session.subscribe, session.getSnapshot, session.getSnapshot);
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/Lifecycle.desktop.tsx

@@ -0,0 +1,31 @@
+import { useEffect } from "react";
+import { Platform } from "react-native";
+import { beforeWindowClose, setWindowTitle, onWindowEvent } from "@legendapp/spark/windows";
+import { beforeQuit } from "@legendapp/spark/app";
+import { configureMenus, clearMenus, addNativeMenuActionListener } from "@legendapp/spark/menus";
+import { registerShortcut, parseAccelerator } from "@legendapp/spark/shortcuts";
+import { mountSerial } from "./lifetime";
+import type { LifecycleProps } from "./lifecycle-types";
+let activeMenuOwner: string | undefined;
+export function Lifecycle({ title, windowId = "main", flush, quit, commands, onError }: LifecycleProps) {
+  useEffect(() => { void setWindowTitle(windowId, title).catch(error => onError(String(error))); }, [title, windowId, onError]);
+  useEffect(() => mountSerial(`window-${windowId}`, async retain => {
+    const owner = `example-${windowId}`;
+    const menu = () => {
+      if (activeMenuOwner && activeMenuOwner !== owner) clearMenus(activeMenuOwner);
+      configureMenus(owner, [{ id: "file", title: "File", items: commands.map(({ id, title, key }) => ({ id, title, shortcut: parseAccelerator(`${Platform.OS === "windows" ? "Control" : "Command"}+${key}`) })) }]);
+      activeMenuOwner = owner;
+    };
+    menu();
+    await retain(Promise.resolve({ remove: () => { clearMenus(owner); if (activeMenuOwner === owner) activeMenuOwner = undefined; } }));
+    await retain(Promise.resolve(addNativeMenuActionListener(event => { if (event.ownerId === owner) commands.find(command => command.id === event.itemId)?.run(); })));
+    await retain(Promise.resolve(onWindowEvent(event => { if (event.windowId === windowId && event.type === "focus") menu(); })));
+    const guarded = (save: () => Promise<boolean>) => async () => {
+      try { return await save(); } catch (error) { onError(String(error)); return false; }
+    };
+    await retain(beforeWindowClose(windowId, guarded(flush)));
+    if (windowId === "main") await retain(beforeQuit(guarded(quit ?? flush)));
+    for (const command of commands) await retain(registerShortcut(`${Platform.OS === "windows" ? "Control" : "Command"}+${command.key}`, command.run, { windowId }));
+  }, onError), [windowId, flush, quit, commands, onError]);
+  return null;
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/Lifecycle.macos.tsx

@@ -0,0 +1 @@
+export { Lifecycle } from "./Lifecycle.desktop";

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/Lifecycle.tsx

@@ -0,0 +1,14 @@
+import { useEffect } from "react";
+import { AppState, BackHandler } from "react-native";
+import type { LifecycleProps } from "./lifecycle-types";
+export function Lifecycle({ flush, dirty }: LifecycleProps) {
+  useEffect(() => {
+    const state = AppState.addEventListener("change", state => { if (state !== "active") void flush(); });
+    const back = BackHandler.addEventListener("hardwareBackPress", () => {
+      if (!dirty()) return false;
+      void flush().then(ok => { if (ok && !dirty()) BackHandler.exitApp(); }); return true;
+    });
+    return () => { state.remove(); back.remove(); };
+  }, [flush, dirty]);
+  return null;
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/Lifecycle.web.tsx

@@ -0,0 +1,20 @@
+import { useEffect } from "react";
+import type { LifecycleProps } from "./lifecycle-types";
+export function Lifecycle({ title, dirty, flush, commands }: LifecycleProps) {
+  useEffect(() => { document.title = title; }, [title]);
+  useEffect(() => {
+    const close = (event: BeforeUnloadEvent) => { if (dirty()) { event.preventDefault(); event.returnValue = ""; } };
+    const background = () => { if (document.visibilityState === "hidden") void flush(); };
+    const key = (event: KeyboardEvent) => {
+      if (event.isComposing || event.altKey || !(event.metaKey || event.ctrlKey)) return;
+      const command = commands.find(command => {
+        const parts = command.key.toLowerCase().split("+");
+        return parts.includes("shift") === event.shiftKey && parts.at(-1) === event.key.toLowerCase();
+      });
+      if (command) { event.preventDefault(); command.run(); }
+    };
+    window.addEventListener("beforeunload", close); window.addEventListener("keydown", key); document.addEventListener("visibilitychange", background);
+    return () => { window.removeEventListener("beforeunload", close); window.removeEventListener("keydown", key); document.removeEventListener("visibilitychange", background); };
+  }, [dirty, flush, commands]);
+  return null;
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/Lifecycle.windows.tsx

@@ -0,0 +1 @@
+export { Lifecycle } from "./Lifecycle.desktop";

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/OpenFiles.desktop.tsx

@@ -0,0 +1,28 @@
+import { useEffect } from "react";
+import { Platform } from "react-native";
+import { onOpen } from "@legendapp/spark/links";
+import { mountSerial } from "./lifetime";
+import type { OpenFilesProps } from "./OpenFiles";
+// onOpen replays queued launches to each subscription. Remounts must not import twice.
+const imported = new Set<string>();
+const importing = new Set<string>();
+export function OpenFiles({ windowId = "main", onFile, onError }: OpenFilesProps) {
+  useEffect(() => {
+    if (windowId !== "main") return;
+    return mountSerial("file-activation", async retain => { await retain(onOpen(event => {
+      if (event.type !== "openFile") return;
+      if (imported.has(event.id) || importing.has(event.id)) return;
+      const match = /^file:\/\/(?:localhost)?(\/.*)$/.exec(event.url);
+      if (!match) { onError("Unsupported file URL"); return; }
+      importing.add(event.id);
+      void (async () => {
+        let path = decodeURIComponent(match[1]!);
+        if (Platform.OS === "windows") path = path.replace(/^\/([a-z]:)/i, "$1").replace(/\//g, "\\");
+        await onFile(path);
+        imported.add(event.id);
+        if (imported.size > 200) imported.delete(imported.values().next().value!);
+      })().catch(error => onError(String(error))).finally(() => importing.delete(event.id));
+    })); }, onError);
+  }, [windowId, onFile, onError]);
+  return null;
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/OpenFiles.macos.tsx

@@ -0,0 +1 @@
+export { OpenFiles } from "./OpenFiles.desktop";

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/OpenFiles.tsx

@@ -0,0 +1,2 @@
+export type OpenFilesProps = { windowId?: string; onFile(path: string): Promise<void>; onError(message: string): void };
+export function OpenFiles(_props: OpenFilesProps) { return null; }

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/OpenFiles.windows.tsx

@@ -0,0 +1 @@
+export { OpenFiles } from "./OpenFiles.desktop";

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/document.ts

@@ -0,0 +1,58 @@
+export type FileReference = { name: string; location?: string; handle?: unknown };
+export type DocumentState = { text: string; savedText: string; file: FileReference; busy: boolean; error: string | null; revision: number };
+export type DocumentIO = {
+  open(): Promise<{ file: FileReference; text: string } | null>;
+  save(file: FileReference, text: string, expected: string, saveAs: boolean): Promise<FileReference | null>;
+  confirmDiscard(name: string): Promise<"save" | "discard" | "cancel">;
+};
+/** One document model is shared by its windows; I/O always works on a snapshot. */
+export class DocumentSession {
+  private state: DocumentState = { text: "", savedText: "", file: { name: "Untitled.txt" }, busy: false, error: null, revision: 0 };
+  private listeners = new Set<() => void>();
+  private active = false;
+  constructor(readonly io: DocumentIO) {}
+  getSnapshot = () => this.state;
+  subscribe = (listener: () => void) => { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; };
+  private update(patch: Partial<DocumentState>) { this.state = { ...this.state, ...patch }; for (const listener of this.listeners) listener(); }
+  edit = (text: string) => { if (text !== this.state.text) this.update({ text, revision: this.state.revision + 1 }); };
+  get dirty() { return this.state.text !== this.state.savedText; }
+  private async operation(action: () => Promise<boolean>) {
+    if (this.active) return false;
+    this.active = true; this.update({ busy: true, error: null });
+    try { return await action(); }
+    catch (error) { this.update({ error: error instanceof Error ? error.message : String(error) }); return false; }
+    finally { this.active = false; this.update({ busy: false }); }
+  }
+  private async saveSnapshot(saveAs: boolean) {
+    const snapshot = this.state;
+    const file = await this.io.save(snapshot.file, snapshot.text, snapshot.savedText, saveAs);
+    if (!file) return false;
+    // Edits typed during an asynchronous save remain dirty.
+    this.update({ file, savedText: snapshot.text }); return true;
+  }
+  save = (saveAs = false) => this.operation(() => this.saveSnapshot(saveAs));
+  private async mayReplace() {
+    if (!this.dirty) return true;
+    const revision = this.state.revision;
+    const answer = await this.io.confirmDiscard(this.state.file.name);
+    if (answer === "cancel") return false;
+    if (answer === "save") return await this.saveSnapshot(false) && !this.dirty;
+    return revision === this.state.revision;
+  }
+  canClose = () => this.operation(() => this.mayReplace());
+  newDocument = () => this.operation(async () => {
+    if (!await this.mayReplace()) return false;
+    this.update({ text: "", savedText: "", file: { name: "Untitled.txt" }, revision: this.state.revision + 1 }); return true;
+  });
+  open = () => this.operation(async () => {
+    if (!await this.mayReplace()) return false;
+    const revision = this.state.revision;
+    const loaded = await this.io.open();
+    if (!loaded || revision !== this.state.revision) return false;
+    this.update({ file: loaded.file, text: loaded.text, savedText: loaded.text, revision: revision + 1 }); return true;
+  });
+  load = (file: FileReference, text: string) => this.operation(async () => {
+    if (!await this.mayReplace()) return false;
+    this.update({ file, text, savedText: text, revision: this.state.revision + 1 }); return true;
+  });
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/io.desktop.ts

@@ -0,0 +1,24 @@
+import { openFileDialog, saveFileDialog, readTextFile, writeTextFile, writeTextFileIfUnchanged } from "@legendapp/spark/dialogs";
+import { Alert } from "react-native";
+import type { DocumentIO } from "./document";
+export const io: DocumentIO = {
+  async open() {
+    const paths = await openFileDialog({ allowedFileTypes: ["txt", "md", "json"], allowsMultipleSelection: false });
+    if (!paths?.[0]) return null;
+    const location = paths[0];
+    return { file: { location, name: location.split(/[\\/]/).pop()! }, text: await readTextFile(location) };
+  },
+  async save(file, text, expected, saveAs) {
+    const location = saveAs || !file.location ? await saveFileDialog({ defaultName: file.name, allowedFileTypes: ["txt", "md", "json"] }) : file.location;
+    if (!location) return null;
+    if (location === file.location) {
+      if (!await writeTextFileIfUnchanged(location, expected, text)) throw new Error("The file changed outside the editor. Use Save As to keep your edits in another file.");
+    } else await writeTextFile(location, text);
+    return { location, name: location.split(/[\\/]/).pop()! };
+  },
+  confirmDiscard: name => new Promise(resolve => Alert.alert("Unsaved changes", `Save changes to ${name}?`, [
+    { text: "Cancel", style: "cancel", onPress: () => resolve("cancel") },
+    { text: "Discard", style: "destructive", onPress: () => resolve("discard") },
+    { text: "Save", onPress: () => resolve("save") },
+  ], { cancelable: false })),
+};

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/io.macos.ts

@@ -0,0 +1,7 @@
+import { io as desktop } from "./io.desktop";
+import { showMessage } from "@legendapp/spark/message-dialog";
+import type { DocumentIO } from "./document";
+export const io: DocumentIO = { ...desktop, async confirmDiscard(name) {
+  const { button } = await showMessage({ title: "Unsaved changes", message: `Save changes to ${name}?`, buttons: ["Cancel", "Discard", "Save"], cancelButton: 0, defaultButton: 2 });
+  return (["cancel", "discard", "save"] as const)[button] ?? "cancel";
+} };

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/io.ts

@@ -0,0 +1,31 @@
+import * as DocumentPicker from "expo-document-picker";
+import * as FileSystem from "expo-file-system/legacy";
+import * as Sharing from "expo-sharing";
+import { Alert } from "react-native";
+import type { DocumentIO } from "./document";
+export const io: DocumentIO = {
+  async open() {
+    const result = await DocumentPicker.getDocumentAsync({ type: ["text/*", "application/json"], copyToCacheDirectory: true });
+    if (result.canceled) return null;
+    const asset = result.assets[0]!;
+    if ((asset.size ?? 0) > 8 * 1024 * 1024) throw new Error("Choose a text file smaller than 8 MB");
+    // The picker returns an imported copy, not permission to overwrite the source.
+    return { file: { name: asset.name }, text: await FileSystem.readAsStringAsync(asset.uri) };
+  },
+  async save(file, text) {
+    if (!await Sharing.isAvailableAsync()) throw new Error("File sharing is unavailable on this device");
+    const directory = FileSystem.documentDirectory;
+    if (!directory) throw new Error("Document storage is unavailable");
+    const name = file.name.replace(/[^a-zA-Z0-9._-]/g, "_") || "Untitled.txt";
+    const location = `${directory}spark-${name}`;
+    await FileSystem.writeAsStringAsync(location, text);
+    await Sharing.shareAsync(location, { mimeType: "text/plain", UTI: "public.plain-text" });
+    // Save commits the app's durable copy, regardless of share-sheet dismissal.
+    return { name: file.name, location };
+  },
+  confirmDiscard: name => new Promise(resolve => Alert.alert("Unsaved changes", `Save a copy of ${name}?`, [
+    { text: "Cancel", style: "cancel", onPress: () => resolve("cancel") },
+    { text: "Discard", style: "destructive", onPress: () => resolve("discard") },
+    { text: "Save", onPress: () => resolve("save") },
+  ], { cancelable: false })),
+};

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/io.web.ts

@@ -0,0 +1,21 @@
+import type { DocumentIO } from "./document";
+export const io: DocumentIO = {
+  open: () => new Promise((resolve, reject) => {
+    const input = document.createElement("input"); input.type = "file"; input.accept = ".txt,.md,.json,text/plain";
+    input.oncancel = () => resolve(null);
+    input.onchange = () => {
+      const file = input.files?.[0];
+      if (!file) { resolve(null); return; }
+      if (file.size > 8 * 1024 * 1024) { reject(new Error("Choose a text file smaller than 8 MB")); return; }
+      void file.text().then(text => resolve({ file: { name: file.name }, text }), reject);
+    };
+    input.click();
+  }),
+  async save(file, text) {
+    const url = URL.createObjectURL(new Blob([text], { type: "text/plain;charset=utf-8" }));
+    const anchor = document.createElement("a"); anchor.href = url; anchor.download = file.name; anchor.click();
+    setTimeout(() => URL.revokeObjectURL(url), 30_000);
+    return { name: file.name };
+  },
+  async confirmDiscard(name) { return window.confirm(`Discard unsaved changes to ${name}? Choose Cancel to return and save.`) ? "discard" : "cancel"; },
+};

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/io.windows.ts

@@ -0,0 +1 @@
+export { io } from "./io.desktop";

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/lifecycle-types.ts

@@ -0,0 +1,10 @@
+export type Command = { id: string; title: string; key: string; run(): void };
+export type LifecycleProps = {
+  windowId?: string;
+  title: string;
+  dirty(): boolean;
+  flush(): Promise<boolean>;
+  quit?(): Promise<boolean>;
+  commands: readonly Command[];
+  onError(message: string): void;
+};

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/lifetime.ts

@@ -0,0 +1,23 @@
+type Subscription = { remove(): void | Promise<void> };
+const lifetimes = new Map<string, Promise<void>>();
+/** Serialize teardown/re-registration across Strict Mode and Fast Refresh. */
+export function mountSerial(key: string, setup: (retain: (item: Promise<Subscription>) => Promise<void>) => Promise<void>, onError: (message: string) => void) {
+  const previous = lifetimes.get(key) ?? Promise.resolve();
+  let finished!: () => void;
+  const closed = new Promise<void>(resolve => { finished = resolve; });
+  lifetimes.set(key, closed);
+  let removed = false;
+  const subscriptions: Subscription[] = [];
+  const ready = previous.then(async () => {
+    if (removed) return;
+    await setup(async item => { const subscription = await item; if (removed) await subscription.remove(); else subscriptions.push(subscription); });
+  }).catch(error => onError(String(error)));
+  return () => {
+    if (removed) return;
+    removed = true;
+    void ready.then(async () => {
+      try { for (const subscription of subscriptions.reverse()) { try { await subscription.remove(); } catch (error) { onError(String(error)); } } }
+      finally { finished(); if (lifetimes.get(key) === closed) lifetimes.delete(key); }
+    });
+  };
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/records.ts

@@ -0,0 +1,51 @@
+export interface RecordStorage {
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+}
+type Envelope = { format: 1; revision: number; data: string; checksum: string };
+function checksum(text: string) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++) hash = Math.imul(hash ^ text.charCodeAt(i), 16777619);
+  return (hash >>> 0).toString(16);
+}
+/** Alternating complete snapshots retain the previous version if a write is interrupted.
+ * One writer per key in this JS runtime; not a cross-process database or encryption.
+ */
+export class Records<T> {
+  private revision = 0;
+  private loaded = false;
+  private tail: Promise<void> = Promise.resolve();
+  constructor(private storage: RecordStorage, private key: string, private decode: (value: unknown) => T) {}
+  async load(): Promise<{ value: T | null; recovered: boolean }> {
+    const raw = await Promise.all([0, 1].map(slot => this.storage.getItem(`${this.key}:${slot}`)));
+    const valid: { revision: number; value: T }[] = [];
+    let invalid = false;
+    for (const text of raw) {
+      if (text === null) continue;
+      let item: Envelope;
+      try {
+        item = JSON.parse(text) as Envelope;
+        if (item.format !== 1 || !Number.isSafeInteger(item.revision) || item.revision < 1 || typeof item.data !== "string" || item.checksum !== checksum(item.data)) throw new Error("Invalid record");
+      } catch { invalid = true; continue; }
+      // A valid envelope with an unknown application schema needs migration, not rollback.
+      valid.push({ revision: item.revision, value: this.decode(JSON.parse(item.data)) });
+    }
+    valid.sort((a, b) => b.revision - a.revision);
+    if (!valid.length && invalid) throw new Error("Stored data could not be read. It has been preserved; restore a backup before editing.");
+    this.revision = valid[0]?.revision ?? 0;
+    this.loaded = true;
+    return { value: valid[0]?.value ?? null, recovered: invalid };
+  }
+  save(value: T): Promise<void> {
+    // Serialize now so later edits cannot change an in-flight snapshot.
+    const data = JSON.stringify(value);
+    const write = this.tail.then(async () => {
+      if (!this.loaded) throw new Error("Load records before saving");
+      const revision = this.revision + 1;
+      await this.storage.setItem(`${this.key}:${revision % 2}`, JSON.stringify({ format: 1, revision, data, checksum: checksum(data) }));
+      this.revision = revision;
+    });
+    this.tail = write.catch(() => {});
+    return write;
+  }
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/storage.ts

@@ -0,0 +1,6 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { Records } from "./records";
+import { projectId } from "./identity";
+export function records<T>(name: string, decode: (value: unknown) => T) {
+  return new Records(AsyncStorage, `spark:${projectId.length}:${projectId}:${name}`, decode);
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/example-shared/useModel.ts

@@ -0,0 +1,6 @@
+import { useSyncExternalStore } from "react";
+export interface Model<T> { subscribe(listener: () => void): () => void; getSnapshot(): T }
+/** React adapter for these examples' external application models. */
+export function useModel<T>(model: Model<T>): T {
+  return useSyncExternalStore(model.subscribe, model.getSnapshot, model.getSnapshot);
+}

package/vendor/node_modules/@legendapp/spark-cli/templates/music-lite/Activation.desktop.tsx

@@ -0,0 +1,4 @@
+import { OpenFiles } from "./shared/OpenFiles";
+import { music } from "./store";
+const open = async (uri: string) => { await music.load(); await music.add([{ id: uri, uri, name: uri.split(/[\\/]/).pop()! }]); };
+export function Activation({ windowId, onError }: { windowId: string; onError(message: string): void }) { return <OpenFiles windowId={windowId} onFile={open} onError={onError} />; }

package/vendor/node_modules/@legendapp/spark-cli/templates/music-lite/Activation.macos.tsx

@@ -0,0 +1 @@
+export { Activation } from "./Activation.desktop";

package/vendor/node_modules/@legendapp/spark-cli/templates/music-lite/Activation.tsx

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

package/vendor/node_modules/@legendapp/spark-cli/templates/music-lite/Activation.windows.tsx

@@ -0,0 +1 @@
+export { Activation } from "./Activation.desktop";