@wildwinter/app-shell 0.57.0 → 0.58.1

package/dist/view-host.cjs

@@ -0,0 +1,532 @@
+'use strict';
+
+var electron = require('electron');
+var path = require('path');
+var url = require('url');
+var extensions = require('@wildwinter/toolkit/extensions');
+var promises = require('fs/promises');
+var zlib = require('zlib');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/view-host.ts
+function rememberBounds(w, write) {
+  const saveBounds = () => {
+    if (!w.isDestroyed()) write(w.getBounds());
+  };
+  let boundsTimer;
+  const queueSave = () => {
+    clearTimeout(boundsTimer);
+    boundsTimer = setTimeout(saveBounds, 400);
+  };
+  w.on("resize", queueSave);
+  w.on("move", queueSave);
+  w.on("close", () => {
+    clearTimeout(boundsTimer);
+    saveBounds();
+  });
+}
+var macPinned = /* @__PURE__ */ new Set();
+var macActivationWired = false;
+function wireMacActivation() {
+  if (macActivationWired) return;
+  macActivationWired = true;
+  electron.app.on("did-become-active", () => {
+    for (const w of macPinned) if (!w.isDestroyed()) w.setAlwaysOnTop(true, "floating");
+  });
+  electron.app.on("did-resign-active", () => {
+    for (const w of macPinned) if (!w.isDestroyed()) w.setAlwaysOnTop(false);
+  });
+}
+function pinToolWindow(w, parent, on, platform = process.platform) {
+  if (!w || w.isDestroyed()) return;
+  if (platform === "darwin") {
+    w.setParentWindow(null);
+    if (on) {
+      if (!macPinned.has(w)) {
+        macPinned.add(w);
+        w.once("closed", () => macPinned.delete(w));
+      }
+      wireMacActivation();
+      w.setAlwaysOnTop(electron.BrowserWindow.getFocusedWindow() !== null, "floating");
+    } else {
+      macPinned.delete(w);
+      w.setAlwaysOnTop(false);
+    }
+    return;
+  }
+  w.setAlwaysOnTop(false);
+  const owner = on && parent && !parent.isDestroyed() ? parent : null;
+  w.setParentWindow(owner);
+}
+function openToolWindow(existing, opts) {
+  if (opts.url === void 0 && (opts.page === void 0 || opts.rendererDir === void 0)) {
+    throw new Error("openToolWindow needs a url, or a page and its rendererDir");
+  }
+  const w = new electron.BrowserWindow({
+    ...opts.rect,
+    ...opts.min !== void 0 ? { minWidth: opts.min.width, minHeight: opts.min.height } : {},
+    show: false,
+    title: opts.title,
+    ...opts.frame !== void 0 ? { frame: opts.frame } : {},
+    webPreferences: {
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: true,
+      // Electron's defaults, said out loud: no webview tag, and a dropped file never navigates the window.
+      webviewTag: false,
+      navigateOnDragDrop: false,
+      preload: opts.preload,
+      ...opts.partition !== void 0 ? { partition: opts.partition } : {},
+      ...opts.devTools !== void 0 ? { devTools: opts.devTools } : {}
+    }
+  });
+  if (opts.pinTo !== void 0) pinToolWindow(w, opts.pinTo(), opts.pinned ?? false);
+  if (opts.remember) rememberBounds(w, opts.remember);
+  w.once("ready-to-show", () => w.show());
+  if (opts.onClosed) w.on("closed", opts.onClosed);
+  if (opts.url !== void 0) void w.loadURL(opts.url);
+  else if (process.env["ELECTRON_RENDERER_URL"]) void w.loadURL(`${process.env["ELECTRON_RENDERER_URL"]}/${opts.page}`);
+  else void w.loadFile(path.join(opts.rendererDir, opts.page));
+  return w;
+}
+
+// src/view-protocol.ts
+var VIEW_PORT_CHANNEL = "wildwinter-view:port";
+var VIEW_CSP = [
+  "default-src 'self'",
+  "script-src 'self'",
+  "style-src 'self' 'unsafe-inline'",
+  "img-src 'self' data: blob:",
+  "font-src 'self' data:",
+  "connect-src 'none'",
+  "object-src 'none'",
+  "base-uri 'none'",
+  "form-action 'none'",
+  "frame-src 'none'"
+].join("; ");
+function viewSchemePrivileges(scheme) {
+  return { scheme, privileges: { standard: true, secure: true, supportFetchAPI: true } };
+}
+function viewPageUrl(scheme, extension, view) {
+  return `${scheme}://${extension}/?view=${encodeURIComponent(view)}`;
+}
+var TYPES = {
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".wasm": "application/wasm"
+};
+function viewContentType(path$1) {
+  return TYPES[path.extname(path$1).toLowerCase()] ?? "application/octet-stream";
+}
+var headers = (type) => ({
+  "Content-Type": type,
+  "Content-Security-Policy": VIEW_CSP,
+  "X-Content-Type-Options": "nosniff",
+  "Cache-Control": "no-store"
+});
+var notFound = () => new Response("Not found", { status: 404, headers: headers("text/plain; charset=utf-8") });
+var escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function viewPage(view) {
+  const el = view.element;
+  return `<!doctype html>
+<html><head><meta charset="utf-8"><title>${escapeHtml(view.name)}</title>
+<style>
+html, body { margin: 0; height: 100%; }
+body { background: var(--bg, Canvas); color: var(--ink, CanvasText); font-family: var(--font-ui, system-ui, sans-serif); color-scheme: var(--color-scheme, light dark); }
+body > ${el} { display: block; height: 100%; overflow: auto; }
+</style>
+<script type="module" src="/${view.entry.split("/").map(encodeURIComponent).join("/")}"></script>
+</head><body><${el}></${el}></body></html>
+`;
+}
+async function viewResponse(url, opts) {
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    return notFound();
+  }
+  if (u.protocol !== `${opts.scheme}:`) return notFound();
+  const source = await opts.resolve(u.hostname);
+  if (!source) return notFound();
+  if (u.pathname === "/" || u.pathname === "") {
+    const id = u.searchParams.get("view");
+    const view = id === null ? void 0 : extensions.viewsFor(source.manifest, opts.host).find((v) => v.id === id);
+    if (!view) return notFound();
+    return new Response(viewPage(view), { status: 200, headers: headers("text/html; charset=utf-8") });
+  }
+  const file = await confined(source.root, u.pathname);
+  if (!file) return notFound();
+  try {
+    return new Response(new Uint8Array(await promises.readFile(file)), { status: 200, headers: headers(viewContentType(file)) });
+  } catch {
+    return notFound();
+  }
+}
+async function confined(root, pathname) {
+  let path$1;
+  try {
+    path$1 = decodeURIComponent(pathname);
+  } catch {
+    return null;
+  }
+  if (path$1.includes("\0") || path$1.includes("\\")) return null;
+  const parts = path$1.replace(/^\/+/, "").split("/");
+  if (parts.some((p) => p === "" || p === "." || p === "..")) return null;
+  const full = path.join(root, ...parts);
+  const inside = (base, p) => {
+    const rel = path.relative(base, p);
+    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+  };
+  if (!inside(root, full)) return null;
+  try {
+    const [realRoot, realFull] = await Promise.all([promises.realpath(root), promises.realpath(full)]);
+    return inside(realRoot, realFull) ? realFull : null;
+  } catch {
+    return null;
+  }
+}
+function serveViews(protocol, opts) {
+  protocol.handle(opts.scheme, (request) => viewResponse(request.url, opts));
+}
+function viewRequestAllowed(url, scheme) {
+  const colon = url.indexOf(":");
+  const protocol = colon < 0 ? "" : url.slice(0, colon).toLowerCase();
+  return protocol === scheme || protocol === "devtools" || protocol === "data" || protocol === "blob";
+}
+function guardViewSession(session2, scheme) {
+  session2.webRequest.onBeforeRequest((details, callback) => callback({ cancel: !viewRequestAllowed(details.url, scheme) }));
+  session2.setPermissionRequestHandler((_wc, _permission, callback) => callback(false));
+  session2.setPermissionCheckHandler?.(() => false);
+}
+var ID = /^[a-z][a-z0-9-]*$/;
+var VERSION = /^\d+\.\d+\.\d+$/;
+var MAX_BYTES = 64 * 1024 * 1024;
+var kept = (path) => path.split("/").every((s) => s !== "node_modules" && !s.startsWith("."));
+var safePath = (path) => path !== "" && !path.includes("\\") && !path.includes("\0") && !path.startsWith("/") && path.split("/").every((s) => s !== "" && s !== "." && s !== "..");
+async function readExtensionPackage(path$1) {
+  let stat;
+  try {
+    stat = await promises.lstat(path$1);
+  } catch {
+    return { ok: false, why: `There's nothing at ${path$1}.` };
+  }
+  let files;
+  if (stat.isDirectory()) files = await readFolder(path$1);
+  else if (stat.isFile()) files = readTarball(await promises.readFile(path$1));
+  else return { ok: false, why: `${path.basename(path$1)} isn't a folder or an npm package tarball (.tgz).` };
+  if (typeof files === "string") return { ok: false, why: files };
+  return packageFromFiles(files);
+}
+function packageFromFiles(files) {
+  const manifests = [...files.keys()].filter((p) => !p.includes("/") && p.endsWith(extensions.MANIFEST_FILE_SUFFIX));
+  if (manifests.length === 0) {
+    return { ok: false, why: `This package has no extension manifest (a file such as pattershot${extensions.MANIFEST_FILE_SUFFIX}) at its top level.` };
+  }
+  if (manifests.length > 1) {
+    return { ok: false, why: `This package has more than one extension manifest at its top level: ${manifests.sort().join(", ")}.` };
+  }
+  const file = manifests[0];
+  let manifest;
+  try {
+    manifest = extensions.parseManifest(new TextDecoder().decode(files.get(file)));
+  } catch (e) {
+    return { ok: false, why: `The manifest ${file} won't parse: ${e.message}` };
+  }
+  const problems = extensions.manifestProblems(manifest);
+  const stem = file.slice(0, -extensions.MANIFEST_FILE_SUFFIX.length);
+  if (typeof manifest === "object" && manifest !== null && typeof manifest.id === "string" && manifest.id !== stem) {
+    return { ok: false, why: `The manifest ${file} names the extension "${manifest.id}"; its file name should match.` };
+  }
+  return { ok: true, manifest, problems, files };
+}
+async function readFolder(root) {
+  const files = /* @__PURE__ */ new Map();
+  let total = 0;
+  const walk = async (dir, rel) => {
+    for (const entry of await promises.readdir(dir, { withFileTypes: true })) {
+      const path$1 = rel === "" ? entry.name : `${rel}/${entry.name}`;
+      if (!kept(path$1)) continue;
+      if (entry.isDirectory()) {
+        const why2 = await walk(path.join(dir, entry.name), path$1);
+        if (why2) return why2;
+      } else if (entry.isFile()) {
+        const bytes = await promises.readFile(path.join(dir, entry.name));
+        total += bytes.length;
+        if (total > MAX_BYTES) return tooBig();
+        files.set(path$1, bytes);
+      }
+    }
+    return null;
+  };
+  const why = await walk(root, "");
+  return why ?? files;
+}
+var tooBig = () => `This package is bigger than ${MAX_BYTES / 1024 / 1024} MB, which is more than a view should need.`;
+var notATarball = "This file isn't a folder or an npm package tarball (.tgz).";
+function readTarball(gz) {
+  let tar;
+  try {
+    tar = zlib.gunzipSync(gz, { maxOutputLength: MAX_BYTES * 2 });
+  } catch {
+    return notATarball;
+  }
+  const raw = [];
+  let at = 0;
+  let longName = null;
+  let total = 0;
+  const text = (from, len) => {
+    const slice = tar.subarray(from, from + len);
+    const end = slice.indexOf(0);
+    return slice.subarray(0, end < 0 ? slice.length : end).toString("utf8");
+  };
+  while (at + 512 <= tar.length) {
+    const header = tar.subarray(at, at + 512);
+    if (header.every((b) => b === 0)) break;
+    if (text(at + 257, 5) !== "ustar") return notATarball;
+    const size = parseInt(text(at + 124, 12).trim() || "0", 8);
+    if (!Number.isFinite(size) || size < 0) return notATarball;
+    const type = String.fromCharCode(header[156]);
+    const prefix = text(at + 345, 155);
+    const name = prefix ? `${prefix}/${text(at, 100)}` : text(at, 100);
+    const body = tar.subarray(at + 512, at + 512 + size);
+    if (body.length < size) return notATarball;
+    at += 512 + Math.ceil(size / 512) * 512;
+    if (type === "x") {
+      longName = paxPath(body.toString("utf8")) ?? longName;
+      continue;
+    }
+    if (type === "L") {
+      longName = body.toString("utf8").replace(/\0+$/, "");
+      continue;
+    }
+    if (type === "g") continue;
+    const path = (longName ?? name).replace(/^\.\//, "");
+    longName = null;
+    if (type !== "0" && type !== "\0") continue;
+    if (!safePath(path)) return "This package holds a file that would land outside it, so it won't be read.";
+    total += size;
+    if (total > MAX_BYTES) return tooBig();
+    raw.push([path, new Uint8Array(body)]);
+  }
+  const tops = new Set(raw.map(([p]) => p.split("/")[0]));
+  const strip = tops.size === 1 && raw.every(([p]) => p.includes("/"));
+  const files = /* @__PURE__ */ new Map();
+  for (const [p, bytes] of raw) {
+    const path = strip ? p.slice(p.indexOf("/") + 1) : p;
+    if (kept(path)) files.set(path, bytes);
+  }
+  return files;
+}
+function paxPath(records) {
+  for (const line of records.split("\n")) {
+    const m = /^\d+ path=(.*)$/.exec(line);
+    if (m) return m[1];
+  }
+  return null;
+}
+async function installExtensionPackage(pkg, dir) {
+  const { manifest } = pkg;
+  const name = typeof manifest.name === "string" ? manifest.name : "This extension";
+  const errors = pkg.problems.filter((p) => p.severity === "error");
+  if (errors.length > 0 || !ID.test(manifest.id) || !VERSION.test(manifest.version)) {
+    const first = errors[0];
+    return { ok: false, why: `${name}'s manifest has a fault, so it won't install${first ? `: ${first.message}` : ""}.` };
+  }
+  const home = path.join(dir, manifest.id);
+  const target = path.join(home, manifest.version);
+  const stamp = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const temp = path.join(home, `.installing-${manifest.version}-${stamp}`);
+  const old = path.join(home, `.replaced-${manifest.version}-${stamp}`);
+  try {
+    await promises.mkdir(temp, { recursive: true });
+    for (const [path$1, bytes] of pkg.files) {
+      if (!safePath(path$1) || !kept(path$1)) continue;
+      const to = path.join(temp, ...path$1.split("/"));
+      await promises.mkdir(path.dirname(to), { recursive: true });
+      await promises.writeFile(to, bytes);
+    }
+    let replaced = false;
+    try {
+      await promises.rename(target, old);
+      replaced = true;
+    } catch {
+    }
+    try {
+      await promises.rename(temp, target);
+    } catch (e) {
+      if (replaced) await promises.rename(old, target).catch(() => {
+      });
+      throw e;
+    }
+    if (replaced) await promises.rm(old, { recursive: true, force: true });
+  } catch (e) {
+    await promises.rm(temp, { recursive: true, force: true }).catch(() => {
+    });
+    return { ok: false, why: `${name} couldn't be installed: ${e.message}` };
+  }
+  return { ok: true, installed: { id: manifest.id, version: manifest.version, manifest, root: target } };
+}
+async function removeInstalledExtension(dir, id, version) {
+  if (!ID.test(id) || version !== void 0 && !VERSION.test(version)) return;
+  await promises.rm(version === void 0 ? path.join(dir, id) : path.join(dir, id, version), { recursive: true, force: true });
+}
+async function installedExtensions(dir) {
+  const out = [];
+  const names = async (path) => {
+    try {
+      return (await promises.readdir(path, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+      return [];
+    }
+  };
+  for (const id of (await names(dir)).filter((n) => ID.test(n)).sort()) {
+    for (const version of (await names(path.join(dir, id))).filter((n) => VERSION.test(n))) {
+      const root = path.join(dir, id, version);
+      try {
+        const manifest = extensions.parseManifest(await promises.readFile(path.join(root, `${id}${extensions.MANIFEST_FILE_SUFFIX}`), "utf8"));
+        if (manifest.id !== id || manifest.version !== version) continue;
+        out.push({ id, version, manifest, root });
+      } catch {
+      }
+    }
+  }
+  return out.sort((a, b) => a.id === b.id ? compareVersions(a.version, b.version) : a.id < b.id ? -1 : 1);
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number), pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) - (pb[i] ?? 0);
+  return 0;
+}
+function chooseInstalled(installed, id, pinned, name) {
+  const mine = installed.filter((x) => x.id === id).sort((a, b) => compareVersions(b.version, a.version));
+  const called = name ?? mine[0]?.manifest.name ?? id;
+  if (mine.length === 0) return { installed: null, why: `${called} isn't installed on this machine.` };
+  if (pinned === void 0) return { installed: mine[0] };
+  const exact = mine.find((x) => x.version === pinned);
+  if (exact) return { installed: exact };
+  const major = pinned.split(".")[0];
+  const same = mine.find((x) => x.version.split(".")[0] === major);
+  if (same) return { installed: same, warning: `This project expects ${called} ${pinned}; ${same.version} is installed.` };
+  return {
+    installed: null,
+    why: `This project expects ${called} ${pinned}; ${mine[0].version} is installed, and a different major version won't open.`
+  };
+}
+async function resolveInstalled(dir, id, pinned, name) {
+  return chooseInstalled(await installedExtensions(dir), id, pinned, name);
+}
+
+// src/view-host.ts
+function viewPreloadPath() {
+  const here = typeof __dirname === "string" ? __dirname : path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('view-host.cjs', document.baseURI).href))));
+  return path.join(here, "view-preload.cjs");
+}
+var viewPartition = (extension) => `view-${extension}`;
+var served = /* @__PURE__ */ new Map();
+function prepareViewSession(extension, source, scheme, host) {
+  const partition = viewPartition(extension);
+  const known = served.has(partition);
+  served.set(partition, source);
+  if (known) return;
+  const ses = electron.session.fromPartition(partition);
+  serveViews(ses.protocol, { scheme, host, resolve: (id) => id === extension ? served.get(partition) ?? null : null });
+  guardViewSession(ses, scheme);
+}
+function openViewWindow(opts) {
+  const { installed, editor } = opts;
+  const decl = extensions.viewsFor(installed.manifest, opts.host).find((v) => v.id === opts.view);
+  if (!decl) throw new Error(`${installed.manifest.name} has no view called "${opts.view}" in this app.`);
+  prepareViewSession(installed.id, { root: installed.root, manifest: installed.manifest }, opts.scheme, opts.host);
+  const w = openToolWindow(null, {
+    title: opts.title ?? decl.name,
+    url: viewPageUrl(opts.scheme, installed.id, decl.id),
+    preload: opts.preload ?? viewPreloadPath(),
+    partition: viewPartition(installed.id),
+    devTools: opts.devTools ?? false,
+    rect: opts.rect,
+    frame: opts.frame ?? true,
+    ...opts.min !== void 0 ? { min: opts.min } : {},
+    ...opts.pinTo !== void 0 ? { pinTo: opts.pinTo } : {},
+    ...opts.pinned !== void 0 ? { pinned: opts.pinned } : {},
+    ...opts.remember !== void 0 ? { remember: opts.remember } : {},
+    ...opts.onClosed !== void 0 ? { onClosed: opts.onClosed } : {}
+  });
+  const meta = {
+    window: w.id,
+    extension: installed.id,
+    view: decl.id,
+    version: installed.version,
+    ...opts.pinnedVersion !== void 0 ? { pinned: opts.pinnedVersion } : {}
+  };
+  let viewLoaded = false;
+  const handOver = () => {
+    if (w.isDestroyed() || editor.isDestroyed()) return;
+    const { port1, port2 } = new electron.MessageChannelMain();
+    w.webContents.postMessage(VIEW_PORT_CHANNEL, null, [port1]);
+    editor.webContents.postMessage(VIEW_PORT_CHANNEL, meta, [port2]);
+  };
+  const onViewLoad = () => {
+    viewLoaded = true;
+    handOver();
+  };
+  const onEditorLoad = () => {
+    if (viewLoaded) handOver();
+  };
+  const close = () => {
+    if (!w.isDestroyed()) w.close();
+  };
+  w.webContents.on("did-finish-load", onViewLoad);
+  editor.webContents.on("did-finish-load", onEditorLoad);
+  editor.once("closed", close);
+  w.once("closed", () => {
+    if (!editor.isDestroyed()) {
+      editor.webContents.postMessage(VIEW_PORT_CHANNEL, { ...meta, closed: true }, []);
+      editor.webContents.removeListener("did-finish-load", onEditorLoad);
+      editor.removeListener("closed", close);
+    }
+  });
+  return { window: w, meta, close };
+}
+
+exports.VIEW_CSP = VIEW_CSP;
+exports.chooseInstalled = chooseInstalled;
+exports.compareVersions = compareVersions;
+exports.confined = confined;
+exports.guardViewSession = guardViewSession;
+exports.installExtensionPackage = installExtensionPackage;
+exports.installedExtensions = installedExtensions;
+exports.openViewWindow = openViewWindow;
+exports.packageFromFiles = packageFromFiles;
+exports.readExtensionPackage = readExtensionPackage;
+exports.readTarball = readTarball;
+exports.removeInstalledExtension = removeInstalledExtension;
+exports.resolveInstalled = resolveInstalled;
+exports.serveViews = serveViews;
+exports.viewContentType = viewContentType;
+exports.viewPage = viewPage;
+exports.viewPageUrl = viewPageUrl;
+exports.viewPartition = viewPartition;
+exports.viewPreloadPath = viewPreloadPath;
+exports.viewRequestAllowed = viewRequestAllowed;
+exports.viewResponse = viewResponse;
+exports.viewSchemePrivileges = viewSchemePrivileges;
+//# sourceMappingURL=view-host.cjs.map
+//# sourceMappingURL=view-host.cjs.map