@swf2es/desktop 0.1.20 → 0.1.22

package/src/main/air-bridge.ts

@@ -0,0 +1,185 @@
+// An AIR application's reach through the main process (shared/api.ts
+// DesktopAir): its file system, its EncryptedLocalStore, its window and
+// the screens. air.ts does the work apart from Electron.
+import { readFile, realpath } from "node:fs/promises";
+import {
+  app,
+  type BrowserWindow,
+  type IpcMainEvent,
+  type IpcMainInvokeEvent,
+  ipcMain,
+  screen,
+} from "electron";
+import type { AirScreenState, AirWindowState } from "../shared/api.js";
+import { createDirectoryOf, listOf, moveOf, readOf, removeOf, statOf, writeOf } from "./air.ts";
+import { resolveCase } from "./case-paths.ts";
+import { air, encryptedItems } from "./open.ts";
+import { sandbox, trusted, window } from "./state.ts";
+
+/** The window as an AIR application's NativeWindow reads it. */
+function windowState(w: BrowserWindow): AirWindowState {
+  const bounds = w.getBounds();
+  const content = w.getContentBounds();
+  return {
+    bounds,
+    contentOffset: { x: content.x - bounds.x, y: content.y - bounds.y },
+    title: w.getTitle(),
+    displayState: w.isMinimized() ? "minimized" : w.isMaximized() ? "maximized" : "normal",
+    active: w.isFocused(),
+    visible: w.isVisible(),
+  };
+}
+
+/** The displays as an AIR application's Screen reads them: the work area is past the system's bars. */
+function screenStates(): AirScreenState[] {
+  const primary = screen.getPrimaryDisplay().id;
+  return screen.getAllDisplays().map((display) => ({
+    bounds: display.bounds,
+    visibleBounds: display.workArea,
+    colorDepth: display.colorDepth,
+    main: display.id === primary,
+  }));
+}
+
+/**
+ * An AIR application's reach, shared/api.ts DesktopAir: the file system
+ * and the window, only while one the user opened plays and only for its
+ * page. The file system is read synchronously where File reads it so.
+ */
+export function listenForAir(): void {
+  const playing = (event: IpcMainEvent | IpcMainInvokeEvent) =>
+    trusted(event) && sandbox.application;
+  ipcMain.on("air:stat", (event, path: unknown) => {
+    event.returnValue = playing(event) && typeof path === "string" ? statOf(path) : null;
+  });
+  ipcMain.on("air:list", (event, path: unknown) => {
+    event.returnValue = playing(event) && typeof path === "string" ? listOf(path) : null;
+  });
+  // FileStream's open, which reads a file at once, as stat does: only once the application plays.
+  ipcMain.on("air:read-sync", (event, path: unknown) => {
+    event.returnValue = playing(event) && typeof path === "string" ? readOf(path) : null;
+  });
+  // EncryptedLocalStore, at once as its methods are: only the application playing's.
+  const items = (event: IpcMainEvent) => (playing(event) ? encryptedItems : null);
+  ipcMain.on("air:item-get", (event, name: unknown) => {
+    event.returnValue = typeof name === "string" ? (items(event)?.get(name) ?? null) : null;
+  });
+  ipcMain.on("air:item-set", (event, name: unknown, bytes: unknown) => {
+    if (typeof name === "string" && bytes instanceof Uint8Array) {
+      items(event)?.set(name, bytes);
+    }
+
+    event.returnValue = null;
+  });
+  ipcMain.on("air:item-remove", (event, name: unknown) => {
+    if (typeof name === "string") {
+      items(event)?.remove(name);
+    }
+
+    event.returnValue = null;
+  });
+  ipcMain.on("air:items-reset", (event) => {
+    items(event)?.reset();
+    event.returnValue = null;
+  });
+  // FileStream's writes and File's changes, at once as adl's: only once the application plays.
+  ipcMain.on(
+    "air:write-sync",
+    (event, path: unknown, bytes: unknown, offset: unknown, length: unknown) => {
+      event.returnValue =
+        playing(event) &&
+        typeof path === "string" &&
+        bytes instanceof Uint8Array &&
+        Number.isSafeInteger(offset) &&
+        Number.isSafeInteger(length) &&
+        (offset as number) >= 0 &&
+        (length as number) >= 0 &&
+        writeOf(path, bytes, offset as number, length as number);
+    },
+  );
+  ipcMain.on("air:create-directory", (event, path: unknown) => {
+    event.returnValue = playing(event) && typeof path === "string" && createDirectoryOf(path);
+  });
+  ipcMain.on("air:remove", (event, path: unknown) => {
+    event.returnValue = playing(event) && typeof path === "string" && removeOf(path);
+  });
+  ipcMain.on("air:move", (event, from: unknown, to: unknown) => {
+    event.returnValue =
+      playing(event) && typeof from === "string" && typeof to === "string" && moveOf(from, to);
+  });
+  // A read is what starts the application's grant: the page reads its content SWF first.
+  ipcMain.handle("air:read", async (event, path: unknown) => {
+    if (!trusted(event) || typeof path !== "string" || !air) {
+      return null;
+    }
+
+    try {
+      const real = await realpath(resolveCase(path));
+      return sandbox.startApplication(real) ? new Uint8Array(await readFile(real)) : null;
+    } catch {
+      return null;
+    }
+  });
+  ipcMain.on("air:window", (event) => {
+    event.returnValue = playing(event) && window ? windowState(window) : null;
+  });
+  ipcMain.on("air:screens", (event) => {
+    event.returnValue = playing(event) ? screenStates() : [];
+  });
+  ipcMain.on("air:set-bounds", (event, bounds: unknown) => {
+    const b = bounds as { x?: unknown; y?: unknown; width?: unknown; height?: unknown } | null;
+    const n = (v: unknown) => (typeof v === "number" && Number.isFinite(v) ? Math.round(v) : null);
+    const [x, y, width, height] = [n(b?.x), n(b?.y), n(b?.width), n(b?.height)];
+    if (
+      playing(event) &&
+      window &&
+      x !== null &&
+      y !== null &&
+      width &&
+      height &&
+      width > 0 &&
+      height > 0
+    ) {
+      window.setBounds({ x, y, width, height });
+    }
+  });
+  ipcMain.on("air:set-title", (event, title: unknown) => {
+    if (playing(event) && window && typeof title === "string") {
+      window.setTitle(title.slice(0, 1024));
+    }
+  });
+  ipcMain.on("air:window-do", (event, what: unknown) => {
+    if (!playing(event) || !window) {
+      return;
+    }
+
+    switch (what) {
+      case "minimize":
+        window.minimize();
+        break;
+      case "maximize":
+        window.maximize();
+        break;
+      case "restore":
+        window.restore();
+        break;
+      case "activate":
+        window.focus();
+        break;
+      case "show":
+        window.show();
+        break;
+      case "hide":
+        window.hide();
+        break;
+      case "close":
+        window.close();
+        break;
+    }
+  });
+  ipcMain.on("air:exit", (event, code: unknown) => {
+    if (playing(event)) {
+      app.exit(typeof code === "number" ? code | 0 : 0);
+    }
+  });
+}

package/src/main/dialogs.ts

@@ -0,0 +1,147 @@
+// The app's dialogs: an error, File › Open, the library chooser, and the
+// URL dialog, a window of its own.
+import { basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { BrowserWindow, dialog, type IpcMainEvent, type IpcMainInvokeEvent } from "electron";
+import type { LibraryName } from "../shared/api.js";
+import { buildMenu } from "./menu.ts";
+import { openChosen, readStart } from "./open.ts";
+import { APP_ORIGIN } from "./protocol.ts";
+import { settings, window } from "./state.ts";
+
+const promptPreload = fileURLToPath(new URL("../preload/prompt.cjs", import.meta.url));
+const PROMPT_URL = `${APP_ORIGIN}/open-url.html`;
+
+/** The dialog that asks for a URL, while it is open. */
+export let prompt: BrowserWindow | null = null;
+
+export function refuse(message: string, detail: string): void {
+  if (window) {
+    void dialog.showMessageBox(window, { type: "error", message, detail });
+  }
+}
+
+export async function showOpenDialog(): Promise<void> {
+  if (!window) {
+    return;
+  }
+
+  const result = await dialog.showOpenDialog(window, {
+    title: "Open a SWF or an AIR application",
+    properties: ["openFile"],
+    filters: [
+      { name: "SWF and AIR application descriptors", extensions: ["swf", "xml"] },
+      { name: "All files", extensions: ["*"] },
+    ],
+  });
+  if (!result.canceled && result.filePaths[0]) {
+    await openChosen(result.filePaths[0]);
+  }
+}
+
+/** Ask for a library, check that it is ABC, keep its path, and start the page again with it. */
+export async function chooseLibrary(name: LibraryName): Promise<void> {
+  if (!window) {
+    return;
+  }
+
+  const result = await dialog.showOpenDialog(window, {
+    title: `Choose ${name}.abc`,
+    properties: ["openFile"],
+    filters: [
+      { name: "ActionScript bytecode", extensions: ["abc"] },
+      { name: "All files", extensions: ["*"] },
+    ],
+  });
+  const path = result.filePaths[0];
+  if (result.canceled || !path) {
+    return;
+  }
+
+  // An ABC starts with its minor version, then its major one, 46.
+  const head = await readStart(path, 4);
+  if (head?.[2] !== 46 || head[3] !== 0) {
+    refuse(`${basename(path)} is not an ABC file.`, `swf2es needs ${name}.abc itself.`);
+    return;
+  }
+
+  if (!settings.setLibrary(name, path)) {
+    refuse("The settings could not be saved.", `swf2es uses ${path} until it quits.`);
+  }
+
+  buildMenu();
+
+  // The page fetched the libraries once; a fresh page fetches the new one.
+  window.webContents.reload();
+}
+
+/** Play on the library the app ships again, in place of one the user chose. */
+export function resetLibrary(name: LibraryName): void {
+  if (!settings.clearLibrary(name)) {
+    refuse("The settings could not be saved.", `swf2es uses its own ${name} until it quits.`);
+  }
+
+  buildMenu();
+  window?.webContents.reload();
+}
+
+/**
+ * The dialog that asks for a SWF's URL: a window of its own, apart from the
+ * page, so that only the user, and never a SWF, opens one by its URL.
+ */
+export function showUrlDialog(): void {
+  if (!window) {
+    return;
+  }
+
+  if (prompt) {
+    prompt.focus();
+    return;
+  }
+
+  const dialogWindow = new BrowserWindow({
+    parent: window,
+    modal: true,
+    width: 560,
+    height: 180,
+    resizable: false,
+    minimizable: false,
+    maximizable: false,
+    fullscreenable: false,
+    title: "Open URL",
+    show: false,
+    webPreferences: {
+      preload: promptPreload,
+      contextIsolation: true,
+      sandbox: true,
+      nodeIntegration: false,
+      webSecurity: true,
+      spellcheck: false,
+    },
+  });
+  prompt = dialogWindow;
+  dialogWindow.setMenu(null);
+  dialogWindow.on("page-title-updated", (event) => event.preventDefault());
+  dialogWindow.once("ready-to-show", () => dialogWindow.show());
+  dialogWindow.on("closed", () => {
+    if (prompt === dialogWindow) {
+      prompt = null;
+    }
+  });
+  const contents = dialogWindow.webContents;
+  contents.on("will-navigate", (event) => event.preventDefault());
+  contents.setWindowOpenHandler(() => ({ action: "deny" }));
+  void dialogWindow.loadURL(PROMPT_URL);
+}
+
+/** Whether a message comes from the URL dialog's own page. */
+export function fromPrompt(event: IpcMainEvent | IpcMainInvokeEvent): boolean {
+  const frame = event.senderFrame;
+  return (
+    prompt !== null &&
+    event.sender === prompt.webContents &&
+    frame !== null &&
+    frame.parent === null &&
+    frame.url === PROMPT_URL
+  );
+}