@swf2es/desktop 0.0.0-stage → 0.1.14

package/src/preload/preload.cts

@@ -0,0 +1,110 @@
+// The page's one way to the shell, window.swf2esDesktop: a few messages,
+// each checked again by the main process. A sandboxed preload is a
+// CommonJS script that may require only Electron's renderer modules.
+import type {
+  DesktopApi,
+  LibraryName,
+  NetworkResponse,
+  OpenedMovie,
+  SocketEvent,
+} from "../shared/api.js";
+
+const { contextBridge, ipcRenderer, webUtils } = require("electron") as typeof import("electron");
+
+let nextSocket = 1;
+let nextRequest = 1;
+/** The requests waiting for their response, by number. */
+const responses = new Map<number, (response: NetworkResponse) => void>();
+ipcRenderer.on("net:response", (_event, id: number, response: NetworkResponse) =>
+  responses.get(id)?.(response),
+);
+
+const api: DesktopApi = {
+  files: {
+    browse: (filters, multiple) => ipcRenderer.invoke("files:browse", filters, multiple),
+    save: (name) => ipcRenderer.invoke("files:save", name),
+    read: (id) => ipcRenderer.invoke("files:read", id),
+    write: (id, bytes) => ipcRenderer.invoke("files:write", id, bytes),
+    release: (id) => ipcRenderer.send("files:release", id),
+  },
+  start: () => ipcRenderer.invoke("desktop:start"),
+  onOpen: (listener) => {
+    ipcRenderer.on("desktop:open", (_event, movie: OpenedMovie) => listener(movie));
+  },
+  onClose: (listener) => {
+    ipcRenderer.on("desktop:close", () => listener());
+  },
+  openDialog: () => ipcRenderer.send("desktop:open-dialog"),
+  openUrlDialog: () => ipcRenderer.send("desktop:open-url-dialog"),
+  // The page never sees the path, only the URL the shell gives back.
+  openDropped: (file) => ipcRenderer.send("desktop:open-path", webUtils.getPathForFile(file)),
+  chooseLibrary: (name: LibraryName) => ipcRenderer.send("desktop:choose-library", name),
+  sockets: {
+    connect: (host, port) => {
+      const id = nextSocket++;
+      ipcRenderer.send("socket:connect", id, String(host), Number(port));
+      return id;
+    },
+    send: (id, bytes) => ipcRenderer.send("socket:send", id, bytes),
+    close: (id) => ipcRenderer.send("socket:close", id),
+    onEvent: (listener) => {
+      ipcRenderer.on("socket:event", (_event, id: number, event: SocketEvent) =>
+        listener(id, event),
+      );
+    },
+  },
+  network: {
+    fetch: (request, cancel) => {
+      const id = nextRequest++;
+      cancel(() => ipcRenderer.send("net:abort", id));
+      // The response comes as a message of its own, before the answer that says it went.
+      return new Promise<NetworkResponse>((resolve, reject) => {
+        responses.set(id, (response) => {
+          responses.delete(id);
+          resolve(response);
+        });
+        ipcRenderer.invoke("net:fetch", id, request).then(
+          ({ delivered }: { delivered: boolean }) => {
+            if (!delivered) {
+              responses.delete(id);
+              reject(new Error("swf2es: the request was refused"));
+            }
+          },
+          (error: unknown) => {
+            responses.delete(id);
+            reject(error);
+          },
+        );
+      });
+    },
+    loadPolicyFile: (url) => ipcRenderer.send("net:policy-file", String(url)),
+  },
+  // Synchronous where File and NativeWindow read: their properties answer at once.
+  air: {
+    stat: (path) => ipcRenderer.sendSync("air:stat", String(path)),
+    list: (path) => ipcRenderer.sendSync("air:list", String(path)),
+    read: (path) => ipcRenderer.invoke("air:read", String(path)),
+    readSync: (path) => ipcRenderer.sendSync("air:read-sync", String(path)),
+    getItem: (name) => ipcRenderer.sendSync("air:item-get", String(name)),
+    setItem: (name, bytes) => ipcRenderer.sendSync("air:item-set", String(name), bytes),
+    removeItem: (name) => ipcRenderer.sendSync("air:item-remove", String(name)),
+    resetItems: () => ipcRenderer.sendSync("air:items-reset"),
+    writeSync: (path, bytes, offset, length) =>
+      ipcRenderer.sendSync("air:write-sync", String(path), bytes, Number(offset), Number(length)),
+    createDirectory: (path) => ipcRenderer.sendSync("air:create-directory", String(path)),
+    remove: (path) => ipcRenderer.sendSync("air:remove", String(path)),
+    move: (from, to) => ipcRenderer.sendSync("air:move", String(from), String(to)),
+    window: () => ipcRenderer.sendSync("air:window"),
+    setBounds: (bounds) => ipcRenderer.send("air:set-bounds", bounds),
+    setTitle: (title) => ipcRenderer.send("air:set-title", String(title)),
+    minimize: () => ipcRenderer.send("air:window-do", "minimize"),
+    maximize: () => ipcRenderer.send("air:window-do", "maximize"),
+    restore: () => ipcRenderer.send("air:window-do", "restore"),
+    activate: () => ipcRenderer.send("air:window-do", "activate"),
+    setVisible: (visible) => ipcRenderer.send("air:window-do", visible ? "show" : "hide"),
+    close: () => ipcRenderer.send("air:window-do", "close"),
+    exit: (code) => ipcRenderer.send("air:exit", Number(code) | 0),
+  },
+};
+
+contextBridge.exposeInMainWorld("swf2esDesktop", api);

package/src/preload/prompt.cts

@@ -0,0 +1,11 @@
+// The URL dialog's one way to the main process, window.swf2esPrompt: what
+// to show first, and the user's answer. Apart from the player's page and
+// its API, so that nothing a SWF runs can open a URL.
+const { contextBridge, ipcRenderer } = require("electron") as typeof import("electron");
+
+contextBridge.exposeInMainWorld("swf2esPrompt", {
+  initial: (): Promise<string> => ipcRenderer.invoke("prompt:initial"),
+  /** The URL to open, or null for none. */
+  answer: (url: string | null) =>
+    ipcRenderer.send("prompt:answer", url === null ? null : String(url)),
+});

package/src/preload/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "../../dist/preload",
+    "tsBuildInfoFile": "../../dist/preload/.tsbuildinfo",
+    "types": ["node"],
+    "lib": ["ES2022", "DOM"]
+  },
+  "include": ["*.cts"],
+  "references": [{ "path": "../shared" }]
+}

package/src/renderer/air.ts

@@ -0,0 +1,100 @@
+// An AIR application the shell opened by its descriptor, as the player
+// sees it: NativeApplication's launch and window, and the file system
+// File reads and writes, all through the shell (window.swf2esDesktop.air),
+// which answers only while that application plays. Its SWFs' app:, app-storage:
+// and file: URLs are read from disk the same way (`airPath`).
+import type { AirApplication, EncryptedStoreHost, FileSystemHost } from "@swf2es/player";
+import type { AirLaunch, DesktopAir } from "../shared/api.js";
+
+/** The player's view of `launch`: its application and window, and its file system. */
+export function airHosts(
+  launch: AirLaunch,
+  air: DesktopAir,
+): {
+  application: AirApplication;
+  fileSystem: FileSystemHost;
+  encryptedStore: EncryptedStoreHost;
+} {
+  return {
+    application: {
+      descriptor: launch.descriptor,
+      id: launch.id,
+      arguments: launch.arguments,
+      currentDirectory: launch.currentDirectory,
+      window: {
+        bounds: () => air.window().bounds,
+        setBounds: (bounds) => air.setBounds(bounds),
+        title: () => air.window().title,
+        setTitle: (title) => air.setTitle(title),
+        displayState: () => air.window().displayState,
+        minimize: () => air.minimize(),
+        maximize: () => air.maximize(),
+        restore: () => air.restore(),
+        active: () => air.window().active,
+        activate: () => air.activate(),
+        visible: () => air.window().visible,
+        setVisible: (visible) => air.setVisible(visible),
+        close: () => air.close(),
+        stageOffset: () => air.window().contentOffset,
+      },
+      exit: (code) => air.exit(code),
+    },
+    fileSystem: {
+      separator: launch.separator,
+      directories: launch.directories,
+      stat: (path) => air.stat(path),
+      list: (path) => air.list(path),
+      read: (path) => air.readSync(path),
+      // A copy of the bytes alone: IPC would carry all of a view's buffer.
+      write: (path, bytes, offset, length) => air.writeSync(path, bytes.slice(), offset, length),
+      createDirectory: (path) => air.createDirectory(path),
+      remove: (path) => air.remove(path),
+      move: (from, to) => air.move(from, to),
+    },
+    encryptedStore: {
+      getItem: (name) => air.getItem(name),
+      // A copy of the bytes alone: IPC would carry all of a view's buffer.
+      setItem: (name, bytes) => air.setItem(name, bytes.slice()),
+      removeItem: (name) => air.removeItem(name),
+      reset: () => air.resetItems(),
+    },
+  };
+}
+
+/**
+ * The native path an app:, app-storage: or file: URL names in `launch`;
+ * null for any other URL. The shell judges what it may read.
+ */
+export function airPath(launch: AirLaunch, url: string): string | null {
+  const m = /^(app|app-storage|file):(.*)$/i.exec(url);
+  if (!m) {
+    return null;
+  }
+
+  const sep = launch.separator;
+  let rest: string;
+  try {
+    // A query or a fragment is no part of the file's name.
+    rest = decodeURIComponent(m[2].replace(/[?#].*$/, ""));
+  } catch {
+    return null;
+  }
+
+  switch (m[1].toLowerCase()) {
+    case "app":
+      return join(launch.directories.application, rest, sep);
+    case "app-storage":
+      return join(launch.directories.applicationStorage, rest, sep);
+    default: {
+      // file:///path, or file:///C:/path on Windows.
+      const path = rest.replace(/^\/\/[^/]*/, "");
+      return sep === "\\" ? path.replace(/^\/([A-Za-z]:)/, "$1").replaceAll("/", "\\") : path;
+    }
+  }
+}
+
+/** `rest`, a URL's path, under `base`, a directory: its segments joined by `sep`. */
+function join(base: string, rest: string, sep: string): string {
+  const segments = rest.split("/").filter((s) => s !== "" && s !== ".");
+  return [base.replace(/[\\/]+$/, ""), ...segments].join(sep);
+}

package/src/renderer/files.ts

@@ -0,0 +1,65 @@
+import type { FileHost } from "@swf2es/player";
+import type { DesktopFiles } from "../shared/api.js";
+
+export function shellFiles(files: DesktopFiles): FileHost {
+  const collected = new FinalizationRegistry<number>((id) => files.release(id));
+  return {
+    async browse(filters, multiple, signal) {
+      const selected = await files.browse(filters, multiple);
+      if (signal.aborted) {
+        for (const file of selected) {
+          files.release(file.id);
+        }
+        return [];
+      }
+
+      signal.addEventListener(
+        "abort",
+        () => {
+          for (const file of selected) {
+            files.release(file.id);
+          }
+        },
+        { once: true },
+      );
+      return selected.map((file) => {
+        const selectedFile: import("@swf2es/player").SelectedFile = {
+          ...file,
+          async read(signal) {
+            signal.throwIfAborted();
+            const bytes = await files.read(file.id);
+            signal.throwIfAborted();
+            return new Uint8Array(bytes);
+          },
+        };
+        collected.register(selectedFile, file.id);
+        return selectedFile;
+      });
+    },
+    async save(name, signal) {
+      const file = await files.save(name);
+      if (!file) {
+        return null;
+      }
+      if (signal.aborted) {
+        files.release(file.id);
+        return null;
+      }
+
+      const release = () => files.release(file.id);
+      signal.addEventListener("abort", release, { once: true });
+      return {
+        name: file.name,
+        async write(bytes, signal) {
+          try {
+            signal.throwIfAborted();
+            await files.write(file.id, bytes);
+          } finally {
+            signal.removeEventListener("abort", release);
+            release();
+          }
+        },
+      };
+    },
+  };
+}

package/src/renderer/index.ts

@@ -0,0 +1,145 @@
+// The desktop app's page: one <swf2es-player> filling the window, and what
+// to do when nothing plays.
+// It reaches the shell only through window.swf2esDesktop (shared/api.ts).
+import { configure, type Swf2esPlayerElement } from "@swf2es/web";
+import type { AirLaunch, DesktopApi, LibraryState, OpenedMovie } from "../shared/api.js";
+import { airHosts, airPath } from "./air.js";
+import { shellFiles } from "./files.js";
+import { shellFetch } from "./network.js";
+import { shellSocketHost } from "./sockets.js";
+
+declare global {
+  interface Window {
+    swf2esDesktop: DesktopApi;
+  }
+}
+
+const desktop = window.swf2esDesktop;
+/** The AIR application playing, whose local URLs are read through the shell; null for a SWF. */
+let airLaunch: AirLaunch | null = null;
+
+configure({
+  cache: true,
+  fileHost: shellFiles(desktop.files),
+  sockets: shellSocketHost(desktop.sockets),
+  fetch: shellFetch(desktop.network, () => {
+    const launch = airLaunch;
+    return launch
+      ? (url) => {
+          const path = airPath(launch, url);
+          return path === null ? null : desktop.air.read(path);
+        }
+      : null;
+  }),
+  loadPolicyFile: (url) => desktop.network.loadPolicyFile(url),
+});
+
+const byId = <T extends HTMLElement>(id: string) => document.getElementById(id) as T;
+const player = byId<Swf2esPlayerElement>("player");
+const welcome = byId<HTMLElement>("welcome");
+const failure = byId<HTMLElement>("failure");
+
+/** A playerglobal.abc the user chose, which the shell serves, in place of swf2es's own. */
+function useLibraries(state: LibraryState): void {
+  configure({
+    libraries: {
+      playerglobal: state.playerglobal !== null ? "/libraries/playerglobal.abc" : undefined,
+    },
+  });
+}
+
+function showFailure(message: string | null): void {
+  failure.hidden = message === null;
+  failure.textContent = message ?? "";
+}
+
+let loadGeneration = 0;
+
+function play(movie: OpenedMovie): void {
+  const generation = ++loadGeneration;
+  airLaunch = movie.air ?? null;
+  configure({
+    sandboxType: movie.sandbox,
+    air: movie.air ? airHosts(movie.air, desktop.air) : null,
+  });
+  showFailure(null);
+  welcome.hidden = true;
+  player.hidden = false;
+  player.load(movie.url).then(
+    () => {
+      if (generation === loadGeneration) {
+        player.focus();
+      }
+    },
+    (error: unknown) => {
+      if (generation !== loadGeneration) {
+        return;
+      }
+
+      player.hidden = true;
+      welcome.hidden = false;
+      showFailure(`${movie.name} did not play: ${error instanceof Error ? error.message : error}`);
+    },
+  );
+}
+
+function close(): void {
+  loadGeneration++;
+  player.destroy();
+  player.hidden = true;
+  welcome.hidden = false;
+  showFailure(null);
+}
+
+byId("open").addEventListener("click", () => desktop.openDialog());
+byId("open-url").addEventListener("click", () => desktop.openUrlDialog());
+
+// A file dropped anywhere is offered to the shell; the page never navigates to it.
+document.addEventListener("dragover", (event) => {
+  event.preventDefault();
+  if (event.dataTransfer) {
+    event.dataTransfer.dropEffect = "copy";
+  }
+});
+document.addEventListener("drop", (event) => {
+  event.preventDefault();
+  const file = event.dataTransfer?.files[0];
+  if (file) {
+    desktop.openDropped(file);
+  }
+});
+
+// An open or close during optional backend loading takes precedence over the startup snapshot.
+let started = false;
+let pending: OpenedMovie | null | undefined;
+desktop.onOpen((movie) => {
+  if (started) {
+    play(movie);
+  } else {
+    pending = movie;
+  }
+});
+desktop.onClose(() => {
+  if (started) {
+    close();
+  } else {
+    pending = null;
+  }
+});
+const state = await desktop.start();
+configure({ build: state.build ?? undefined });
+if (state.stage3D) {
+  try {
+    const { createStage3D } = await import("./stage3d.js");
+    configure({ stage3D: createStage3D });
+  } catch (error) {
+    console.warn("swf2es: Stage3D backend could not be loaded; using default playback.", error);
+  }
+}
+
+useLibraries(state.libraries);
+started = true;
+const movie = pending === undefined ? state.movie : pending;
+if (movie) {
+  play(movie);
+}

package/src/renderer/network.ts

@@ -0,0 +1,56 @@
+// What the SWFs load, through the shell: the player's fetch host. A
+// swf2es://file URL, a local SWF's own files, the page fetches as before,
+// its sandbox judged where the shell serves them; an http or https one
+// goes to the main process, which sends it as Flash's sandboxes and policy
+// files allow (main/network.ts), so the page itself never goes to the
+// network. An AIR application's app:, app-storage: and file: URLs are read
+// from disk through the shell while it plays. Nothing else is fetched.
+import type { FetchRequest, FetchResult } from "@swf2es/player";
+import type { DesktopNetwork } from "../shared/api.js";
+
+export function shellFetch(
+  network: DesktopNetwork,
+  /** An AIR application's local URL read, null where `url` is none; null where none plays. */
+  airFile: () => ((url: string) => Promise<Uint8Array | null> | null) | null = () => null,
+): (request: FetchRequest, signal: AbortSignal) => Promise<FetchResult> {
+  return async (request, signal) => {
+    const local = airFile()?.(request.url);
+    if (local) {
+      const bytes = await local;
+      signal.throwIfAborted();
+      // A file that is not there is a failed load, as a 404 is.
+      return { bytes, status: bytes ? 200 : 404, headers: [] };
+    }
+
+    const url = new URL(request.url);
+    // By its parts: a URL's origin is "null" for a scheme the URL standard does not know.
+    if (url.protocol === "swf2es:" && url.host === "file") {
+      const response = await fetch(url.href, { signal });
+      const headers: [string, string][] = [];
+      response.headers.forEach((value, name) => {
+        headers.push([name, value]);
+      });
+      return {
+        bytes: response.ok ? new Uint8Array(await response.arrayBuffer()) : null,
+        status: response.status,
+        headers,
+      };
+    }
+
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new Error(`swf2es: no ${url.protocol} URL is loaded`);
+    }
+
+    signal.throwIfAborted();
+    return network.fetch(
+      {
+        url: url.href,
+        method: request.method,
+        headers: request.headers.map(([name, value]) => [name, value]),
+        body: request.body,
+        purpose: request.purpose ?? "data",
+      },
+      (abort) => signal.addEventListener("abort", abort, { once: true }),
+    );
+  };
+}

package/src/renderer/open-url.ts

@@ -0,0 +1,50 @@
+// The URL dialog (static/open-url.html): a URL to open a remote SWF by,
+// told the main process through window.swf2esPrompt. Only http and https.
+export {};
+
+declare global {
+  interface Window {
+    swf2esPrompt: {
+      initial(): Promise<string>;
+      answer(url: string | null): void;
+    };
+  }
+}
+
+const shell = window.swf2esPrompt;
+const form = document.getElementById("form") as HTMLFormElement;
+const input = document.getElementById("url") as HTMLInputElement;
+const problem = document.getElementById("problem") as HTMLElement;
+
+function remote(text: string): boolean {
+  try {
+    const url = new URL(text.trim());
+    return (url.protocol === "http:" || url.protocol === "https:") && url.hostname !== "";
+  } catch {
+    return false;
+  }
+}
+
+form.addEventListener("submit", (event) => {
+  event.preventDefault();
+  if (!remote(input.value)) {
+    problem.hidden = false;
+    input.focus();
+    return;
+  }
+
+  shell.answer(input.value.trim());
+});
+document.getElementById("cancel")?.addEventListener("click", () => shell.answer(null));
+document.addEventListener("keydown", (event) => {
+  if (event.key === "Escape") {
+    shell.answer(null);
+  }
+});
+input.addEventListener("input", () => {
+  problem.hidden = true;
+});
+
+input.value = await shell.initial();
+input.focus();
+input.select();

package/src/renderer/sockets.ts

@@ -0,0 +1,42 @@
+// flash.net.Socket over the shell's TCP connections: what the player asks
+// of a SocketHost, carried to the main process and back.
+import type { SocketEvents, SocketHost } from "@swf2es/player";
+import type { DesktopSockets } from "../shared/api.js";
+
+export function shellSocketHost(sockets: DesktopSockets): SocketHost {
+  // Until its close, which the shell sends after an error and after a close asked for.
+  const open = new Map<number, SocketEvents>();
+  sockets.onEvent((id, event) => {
+    const events = open.get(id);
+    if (!events) {
+      return;
+    }
+
+    switch (event.type) {
+      case "open":
+        events.open(event);
+        break;
+      case "data":
+        events.data(event.bytes);
+        break;
+      case "error":
+        events.error(event.message);
+        break;
+      case "close":
+        open.delete(id);
+        events.close();
+        break;
+    }
+  });
+
+  return {
+    connect(host, port, events) {
+      const id = sockets.connect(host, port);
+      open.set(id, events);
+      return {
+        send: (bytes) => sockets.send(id, bytes),
+        close: () => sockets.close(id),
+      };
+    },
+  };
+}

package/src/renderer/stage3d.ts

@@ -0,0 +1,27 @@
+import { WebGLContext3D } from "@swf2es/context3d/webgl";
+import type { Stage3DSurfaceFactory } from "@swf2es/web";
+
+export const createStage3D: Stage3DSurfaceFactory = () => {
+  const canvas = document.createElement("canvas");
+  const gl = canvas.getContext("webgl2", {
+    alpha: false,
+    antialias: false,
+    depth: false,
+    stencil: false,
+    preserveDrawingBuffer: true,
+  });
+  if (!gl) {
+    throw new Error("WebGL2 is unavailable");
+  }
+
+  try {
+    return {
+      canvas,
+      context: new WebGLContext3D(gl),
+      destroy: () => gl.getExtension("WEBGL_lose_context")?.loseContext(),
+    };
+  } catch (error) {
+    gl.getExtension("WEBGL_lose_context")?.loseContext();
+    throw error;
+  }
+};

package/src/renderer/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "../../dist/renderer",
+    "tsBuildInfoFile": "../../dist/renderer/.tsbuildinfo",
+    "types": [],
+    "lib": ["ES2022", "DOM", "DOM.Iterable"]
+  },
+  "include": ["*.ts"],
+  "references": [
+    { "path": "../shared" },
+    { "path": "../../../../packages/context3d/tsconfig.webgl.json" },
+    { "path": "../../../../packages/player" },
+    { "path": "../../../../packages/web" }
+  ]
+}