getobsrv 0.3.0

package/out/main/index.js

@@ -0,0 +1,539 @@
+"use strict";
+const electron = require("electron");
+const promises = require("node:fs/promises");
+const node_path = require("node:path");
+const targetSource = require("./targetSource-w_vWw7zd.js");
+const node_fs = require("node:fs");
+const node_url = require("node:url");
+const IPC = {
+  navigate: "obsrv:navigate",
+  reload: "obsrv:reload",
+  back: "obsrv:back",
+  forward: "obsrv:forward",
+  setViewport: "obsrv:set-viewport",
+  setNativeBounds: "obsrv:set-native-bounds",
+  setMode: "obsrv:set-mode",
+  sendInput: "obsrv:send-input",
+  getHostInfo: "obsrv:get-host-info",
+  getSettings: "obsrv:get-settings",
+  setSettings: "obsrv:set-settings",
+  frame: "obsrv:frame",
+  frameSubscribe: "obsrv:frame-subscribe",
+  urlChanged: "obsrv:url-changed",
+  loadError: "obsrv:load-error",
+  hostChanged: "obsrv:host-changed",
+  targetLoading: "obsrv:target-loading",
+  targetNavigating: "obsrv:target-navigating",
+  syncScroll: "obsrv:sync-scroll",
+  applyScroll: "obsrv:apply-scroll",
+  openImage: "obsrv:open-image",
+  focusUrl: "obsrv:focus-url",
+  openImagePath: "obsrv:open-image-path",
+  readImageFile: "obsrv:read-image-file"
+};
+function attachFrameBus(target, win) {
+  let ready = false;
+  let enabled = true;
+  const gone = () => win.isDestroyed() || win.webContents.isDestroyed();
+  const onFrame = (msg) => {
+    if (!ready || !enabled || gone()) return;
+    win.webContents.send(IPC.frame, msg);
+  };
+  const onSubscribe = (e) => {
+    if (gone() || e.sender !== win.webContents) return;
+    ready = true;
+    if (enabled) target.invalidate();
+  };
+  const onRendererGone = (details) => {
+    if (details.isMainFrame && !details.isSameDocument) ready = false;
+  };
+  target.on("frame", onFrame);
+  electron.ipcMain.on(IPC.frameSubscribe, onSubscribe);
+  win.webContents.on("did-start-navigation", onRendererGone);
+  return {
+    detach() {
+      ready = false;
+      target.off("frame", onFrame);
+      electron.ipcMain.removeListener(IPC.frameSubscribe, onSubscribe);
+      if (!gone()) win.webContents.off("did-start-navigation", onRendererGone);
+    },
+    setEnabled(next) {
+      enabled = next;
+      if (enabled && ready) target.invalidate();
+    }
+  };
+}
+const MAX_RECT = 16384;
+const isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+const isRecord = (v) => typeof v === "object" && v !== null;
+function parseRect(raw) {
+  if (!isRecord(raw)) return null;
+  const { x, y, width, height } = raw;
+  if (!isFiniteNumber(x) || !isFiniteNumber(y) || !isFiniteNumber(width) || !isFiniteNumber(height)) return null;
+  const r = { x: Math.round(x), y: Math.round(y), width: Math.round(width), height: Math.round(height) };
+  for (const v of [r.x, r.y, r.width, r.height]) if (v < 0 || v > MAX_RECT) return null;
+  return r;
+}
+const MODIFIERS = /* @__PURE__ */ new Set([
+  "shift",
+  "control",
+  "alt",
+  "meta",
+  "leftButtonDown",
+  "middleButtonDown",
+  "rightButtonDown"
+]);
+const BUTTONS = /* @__PURE__ */ new Set(["left", "middle", "right"]);
+function parseModifiers(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((m) => typeof m === "string" && MODIFIERS.has(m));
+}
+function parseInputEvent(raw) {
+  if (!isRecord(raw)) return null;
+  const modifiers = parseModifiers(raw.modifiers);
+  switch (raw.type) {
+    case "mouseDown":
+    case "mouseUp":
+    case "mouseMove": {
+      const { x, y, button, clickCount } = raw;
+      if (!isFiniteNumber(x) || !isFiniteNumber(y) || !isFiniteNumber(clickCount)) return null;
+      if (typeof button !== "string" || !BUTTONS.has(button)) return null;
+      return { type: raw.type, x, y, button, clickCount, modifiers };
+    }
+    case "mouseWheel": {
+      const { x, y, deltaX, deltaY } = raw;
+      if (!isFiniteNumber(x) || !isFiniteNumber(y) || !isFiniteNumber(deltaX) || !isFiniteNumber(deltaY)) return null;
+      return { type: "mouseWheel", x, y, deltaX, deltaY, modifiers };
+    }
+    case "keyDown":
+    case "keyUp":
+    case "char": {
+      const { keyCode } = raw;
+      if (typeof keyCode !== "string") return null;
+      return { type: raw.type, keyCode, modifiers };
+    }
+    default:
+      return null;
+  }
+}
+function parseDeviceScaleFactor(raw) {
+  if (raw === void 0) return 1;
+  if (!isFiniteNumber(raw) || raw < 1 || raw > 4) return null;
+  return raw;
+}
+function parseSettings(raw) {
+  if (!isRecord(raw)) return null;
+  const { hostDiagonalInches, hostNits } = raw;
+  if (!isFiniteNumber(hostDiagonalInches) || hostDiagonalInches <= 0) return null;
+  if (!isFiniteNumber(hostNits) || hostNits <= 0) return null;
+  return { hostDiagonalInches, hostNits };
+}
+function parseMode(raw) {
+  return raw === "url" || raw === "image" ? raw : null;
+}
+function parseScrollPos(raw) {
+  if (!isRecord(raw)) return null;
+  const { x, y } = raw;
+  if (!isFiniteNumber(x) || !isFiniteNumber(y) || x < 0 || y < 0) return null;
+  return { x, y };
+}
+const isPositive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+function loadSettings(file) {
+  try {
+    const raw = JSON.parse(node_fs.readFileSync(file, "utf8"));
+    return {
+      hostDiagonalInches: isPositive(raw.hostDiagonalInches) ? raw.hostDiagonalInches : targetSource.DEFAULT_SETTINGS.hostDiagonalInches,
+      hostNits: isPositive(raw.hostNits) ? raw.hostNits : targetSource.DEFAULT_SETTINGS.hostNits
+    };
+  } catch {
+    return { ...targetSource.DEFAULT_SETTINGS };
+  }
+}
+function saveSettings(file, s) {
+  if (!isPositive(s.hostDiagonalInches) || !isPositive(s.hostNits)) throw new RangeError("settings values must be finite and > 0");
+  node_fs.mkdirSync(node_path.dirname(file), { recursive: true });
+  node_fs.writeFileSync(file, JSON.stringify(s, null, 2));
+}
+const TOOLBAR_H = 44;
+const MAX_IMAGE_FILE_BYTES = 64 * 1024 * 1024;
+function hostInfo(win) {
+  try {
+    const d = electron.screen.getDisplayMatching(win.getBounds());
+    return {
+      physicalWidth: Math.round(d.size.width * d.scaleFactor),
+      physicalHeight: Math.round(d.size.height * d.scaleFactor),
+      scaleFactor: d.scaleFactor
+    };
+  } catch {
+    return { physicalWidth: 0, physicalHeight: 0, scaleFactor: 0 };
+  }
+}
+function registerIpc(ctx) {
+  const { win, native, target, bus, sync } = ctx;
+  const settingsFile = node_path.join(electron.app.getPath("userData"), "settings.json");
+  let settings = loadSettings(settingsFile);
+  const fromRenderer = (e) => e.sender === win.webContents;
+  const assertRenderer = (e) => {
+    if (!fromRenderer(e)) throw new Error("ipc: unexpected sender");
+  };
+  electron.ipcMain.handle(IPC.navigate, async (e, url) => {
+    assertRenderer(e);
+    let wanted = url;
+    try {
+      wanted = targetSource.normalizeUrl(url);
+      sync.expect(wanted);
+    } catch {
+    }
+    const [applied] = await Promise.all([native.load(wanted), target.load(wanted)]);
+    return applied;
+  });
+  electron.ipcMain.on(IPC.reload, (e) => {
+    if (!fromRenderer(e)) return;
+    native.reload();
+    target.reload();
+  });
+  electron.ipcMain.on(IPC.back, (e) => {
+    if (!fromRenderer(e)) return;
+    native.back();
+  });
+  electron.ipcMain.on(IPC.forward, (e) => {
+    if (!fromRenderer(e)) return;
+    native.forward();
+  });
+  electron.ipcMain.handle(IPC.setViewport, (e, width, height, rawDsf) => {
+    assertRenderer(e);
+    const dsf = parseDeviceScaleFactor(rawDsf);
+    if (dsf === null) throw new Error("invalid deviceScaleFactor");
+    const v = target.setViewport(width, height, dsf);
+    return { width: v.width, height: v.height };
+  });
+  electron.ipcMain.on(IPC.sendInput, (e, raw) => {
+    if (!fromRenderer(e)) return;
+    const ev = parseInputEvent(raw);
+    if (!ev) return;
+    try {
+      target.sendInput(ev);
+    } catch {
+    }
+  });
+  electron.ipcMain.on(IPC.setMode, (e, raw) => {
+    if (!fromRenderer(e)) return;
+    const mode = parseMode(raw);
+    if (!mode) return;
+    const live = mode === "url";
+    native.setVisible(live);
+    bus.setEnabled(live);
+  });
+  let rendererDrivesLayout = false;
+  const fallbackLayout = () => {
+    if (rendererDrivesLayout) return;
+    const [w = 0, h = 0] = win.getContentSize();
+    native.setBounds({
+      x: 0,
+      y: TOOLBAR_H,
+      width: Math.floor(w / 2),
+      height: Math.max(0, h - TOOLBAR_H)
+    });
+  };
+  fallbackLayout();
+  win.on("resize", fallbackLayout);
+  electron.ipcMain.on(IPC.setNativeBounds, (e, raw) => {
+    if (!fromRenderer(e)) return;
+    const rect = parseRect(raw);
+    if (!rect) return;
+    native.setBounds(rect);
+    rendererDrivesLayout = true;
+  });
+  electron.ipcMain.handle(IPC.getHostInfo, (e) => {
+    assertRenderer(e);
+    return hostInfo(win);
+  });
+  let lastHost = JSON.stringify(hostInfo(win));
+  const pushHostIfChanged = () => {
+    const next = hostInfo(win);
+    const key = JSON.stringify(next);
+    if (key === lastHost) return;
+    lastHost = key;
+    if (!win.isDestroyed() && !win.webContents.isDestroyed()) {
+      win.webContents.send(IPC.hostChanged, next);
+    }
+  };
+  win.on("move", pushHostIfChanged);
+  electron.screen.on("display-metrics-changed", pushHostIfChanged);
+  electron.screen.on("display-added", pushHostIfChanged);
+  electron.screen.on("display-removed", pushHostIfChanged);
+  electron.ipcMain.handle(IPC.getSettings, (e) => {
+    assertRenderer(e);
+    return settings;
+  });
+  electron.ipcMain.handle(IPC.setSettings, (e, raw) => {
+    assertRenderer(e);
+    const s = parseSettings(raw);
+    if (!s) throw new Error("invalid settings");
+    saveSettings(settingsFile, s);
+    settings = s;
+  });
+  electron.ipcMain.handle(IPC.readImageFile, async (e, raw) => {
+    assertRenderer(e);
+    if (typeof raw !== "string" || !targetSource.IMAGE_EXTENSIONS.test(raw)) throw new Error("Unsupported file type");
+    const { size } = await promises.stat(raw);
+    if (size > MAX_IMAGE_FILE_BYTES) {
+      throw new Error(`Image file too large (max ${MAX_IMAGE_FILE_BYTES / 1048576} MB)`);
+    }
+    return promises.readFile(raw);
+  });
+}
+function installMenu({ win, native, target }) {
+  const send = (channel) => {
+    if (!win.isDestroyed()) win.webContents.send(channel);
+  };
+  const template = [
+    { role: "appMenu" },
+    {
+      label: "File",
+      submenu: [
+        {
+          label: "Open Image…",
+          accelerator: "CmdOrCtrl+O",
+          click: () => send(IPC.openImage)
+        },
+        { type: "separator" },
+        { role: "close" }
+      ]
+    },
+    { role: "editMenu" },
+    {
+      label: "View",
+      submenu: [
+        {
+          label: "Reload",
+          accelerator: "CmdOrCtrl+R",
+          click: () => {
+            native.reload();
+            target.reload();
+          }
+        },
+        {
+          label: "Open Location",
+          accelerator: "CmdOrCtrl+L",
+          click: () => send(IPC.focusUrl)
+        },
+        { type: "separator" },
+        {
+          label: "Toggle Developer Tools",
+          accelerator: "Alt+CmdOrCtrl+I",
+          click: () => {
+            if (!win.isDestroyed()) win.webContents.toggleDevTools();
+          }
+        },
+        { type: "separator" },
+        { role: "togglefullscreen" }
+      ]
+    },
+    { role: "windowMenu" }
+  ];
+  electron.Menu.setApplicationMenu(electron.Menu.buildFromTemplate(template));
+}
+const ERR_ABORTED = -3;
+class NativePane {
+  constructor(win, events) {
+    this.events = events;
+    this.view = new electron.WebContentsView({
+      webPreferences: {
+        preload: node_path.join(__dirname, "../preload/sync.js"),
+        contextIsolation: true,
+        sandbox: true,
+        nodeIntegration: false
+      }
+    });
+    this.view.setBackgroundColor("#ffffff");
+    win.contentView.addChildView(this.view);
+    this.view.setBounds(this.bounds);
+    const wc = this.view.webContents;
+    wc.on("did-fail-load", (_e, code, description, url, isMainFrame) => {
+      if (isMainFrame && code !== ERR_ABORTED) this.events.onLoadError({ code, description, url });
+    });
+    wc.on("will-navigate", (e, url) => {
+      const verdict = targetSource.classifyFileNavigation(wc.getURL(), url);
+      if (verdict === "allow") return;
+      e.preventDefault();
+      if (verdict === "image") this.events.onImageDrop(node_url.fileURLToPath(url));
+    });
+    wc.setWindowOpenHandler(({ url }) => {
+      if (url && url !== "about:blank") void this.load(url);
+      return { action: "deny" };
+    });
+  }
+  view;
+  bounds = { x: 0, y: 0, width: 0, height: 0 };
+  visible = true;
+  /** Loads URL-bar input; returns the normalised URL that was requested. */
+  async load(input) {
+    try {
+      const url = targetSource.normalizeUrl(input);
+      try {
+        await this.view.webContents.loadURL(url);
+      } catch {
+      }
+      return url;
+    } catch (e) {
+      const description = e instanceof Error ? e.message : String(e);
+      this.events.onLoadError({ code: 0, description, url: input });
+      return input;
+    }
+  }
+  setBounds(rect) {
+    this.bounds = rect;
+    this.view.setBounds(rect);
+  }
+  getBounds() {
+    return this.bounds;
+  }
+  /** Image mode draws the left pane in the renderer, so the OS-level view hides. */
+  setVisible(visible) {
+    this.visible = visible;
+    this.view.setVisible(visible);
+  }
+  isVisible() {
+    return this.visible;
+  }
+  reload() {
+    this.view.webContents.reload();
+  }
+  back() {
+    this.view.webContents.navigationHistory.goBack();
+  }
+  forward() {
+    this.view.webContents.navigationHistory.goForward();
+  }
+  get webContents() {
+    return this.view.webContents;
+  }
+}
+const LOOP_WINDOW_MS = 1e3;
+const LOOP_ALTERNATIONS = 2;
+function attachSyncBus(native, target, onUrlChanged) {
+  const pending = { native: null, target: null };
+  let lastReported = "";
+  let lastMirror = null;
+  let alternations = 0;
+  let loopWarned = false;
+  function mirror(from, url) {
+    const expected = pending[from];
+    pending[from] = null;
+    if (url !== lastReported || expected !== url) {
+      lastReported = url;
+      onUrlChanged(url);
+    }
+    if (expected === url) return;
+    const to = from === "native" ? "target" : "native";
+    const other = from === "native" ? target : native;
+    if (other.webContents.isDestroyed() || other.webContents.getURL() === url) return;
+    const now = Date.now();
+    if (!lastMirror || now - lastMirror.at >= LOOP_WINDOW_MS) alternations = 0;
+    else if (lastMirror.from === to) alternations++;
+    lastMirror = { from, at: now };
+    if (alternations >= LOOP_ALTERNATIONS) {
+      if (!loopWarned) {
+        loopWarned = true;
+        console.warn(`obsrv: navigation mirror loop broken (${from} -> ${to}: ${url})`);
+      }
+      return;
+    }
+    pending[to] = url;
+    void other.load(url);
+  }
+  const onNativeNav = (_e, url) => mirror("native", url);
+  const onNativeNavInPage = (_e, url, isMainFrame) => {
+    if (isMainFrame) mirror("native", url);
+  };
+  const onTargetNav = (url) => mirror("target", url);
+  native.webContents.on("did-navigate", onNativeNav);
+  native.webContents.on("did-navigate-in-page", onNativeNavInPage);
+  target.on("url-changed", onTargetNav);
+  const onScroll = (e, raw) => {
+    const other = e.sender === native.webContents ? target.webContents : e.sender === target.webContents ? native.webContents : null;
+    if (!other || other.isDestroyed()) return;
+    const pos = parseScrollPos(raw);
+    if (!pos) return;
+    other.send(IPC.applyScroll, pos);
+  };
+  electron.ipcMain.on(IPC.syncScroll, onScroll);
+  return {
+    expect(url) {
+      pending.native = url;
+      pending.target = url;
+    },
+    detach() {
+      electron.ipcMain.off(IPC.syncScroll, onScroll);
+      target.off("url-changed", onTargetNav);
+      if (!native.webContents.isDestroyed()) {
+        native.webContents.off("did-navigate", onNativeNav);
+        native.webContents.off("did-navigate-in-page", onNativeNavInPage);
+      }
+    }
+  };
+}
+function exposeForTests(ctx) {
+  if (process.env.OBSRV_TEST === "1") globalThis.__obsrv = ctx;
+}
+function createMainWindow() {
+  const win = new electron.BrowserWindow({
+    width: 1600,
+    height: 1e3,
+    minWidth: 900,
+    minHeight: 600,
+    title: "Obsrv",
+    backgroundColor: "#111111",
+    show: false,
+    webPreferences: {
+      preload: node_path.join(__dirname, "../preload/app.js"),
+      contextIsolation: true,
+      sandbox: true
+    }
+  });
+  win.once("ready-to-show", () => win.show());
+  if (!electron.app.isPackaged && process.env.ELECTRON_RENDERER_URL)
+    void win.loadURL(process.env.ELECTRON_RENDERER_URL);
+  else void win.loadFile(node_path.join(__dirname, "../renderer/index.html"));
+  return win;
+}
+function boot() {
+  const win = createMainWindow();
+  const native = new NativePane(win, {
+    onLoadError: (err) => {
+      if (!win.isDestroyed()) win.webContents.send(IPC.loadError, err);
+    },
+    // The renderer reads the file back over `readImageFile`; no bytes here.
+    onImageDrop: (path) => {
+      if (!win.isDestroyed()) win.webContents.send(IPC.openImagePath, path);
+    }
+  });
+  const target = new targetSource.TargetSource();
+  target.on("load-error", (err) => {
+    if (!win.isDestroyed()) win.webContents.send(IPC.loadError, err);
+  });
+  target.on("loading", (loading) => {
+    if (!win.isDestroyed()) win.webContents.send(IPC.targetLoading, loading);
+  });
+  target.on("navigating", () => {
+    if (!win.isDestroyed()) win.webContents.send(IPC.targetNavigating);
+  });
+  const bus = attachFrameBus(target, win);
+  const sync = attachSyncBus(native, target, (url) => {
+    if (!win.isDestroyed()) win.webContents.send(IPC.urlChanged, url);
+  });
+  const ctx = { win, native, target, bus, sync };
+  registerIpc(ctx);
+  installMenu(ctx);
+  win.on("close", () => {
+    sync.detach();
+    bus.detach();
+    target.destroy();
+  });
+  sync.expect("about:blank");
+  void native.load("about:blank");
+  exposeForTests(ctx);
+}
+void electron.app.whenReady().then(boot);
+electron.app.on("window-all-closed", () => electron.app.quit());