@mygo-plugins/fetch 0.1.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MyGo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# @mygo-plugins/fetch
+
+A `fetch` for [MyGo](https://github.com/egoist/mygo) apps that makes HTTP
+requests from Go: not subject to CORS, free to set any header (Origin,
+Cookie, User-Agent, ...), with the standard options and a standard
+`Response` whose body streams as Go reads it.
+
+Use the plugin in Go:
+
+```go
+import "github.com/egoist/mygo/plugins/fetch"
+
+mygo.Use(fetch.Plugin) // or fetch.New(fetch.Options{Client: ..., Allow: ...})
+```
+
+and fetch in the frontend:
+
+```ts
+import { fetch } from "@mygo-plugins/fetch";
+
+const ctrl = new AbortController();
+const res = await fetch("https://api.example.com/items", {
+  headers: { authorization: `Bearer ${token}` },
+  signal: ctrl.signal, // aborting cancels the request in Go
+});
+const items = await res.json();
+```
+
+- Aborting the signal, canceling the body, navigating away or closing the
+  window cancels the request in Go.
+- `redirect: "manual"` returns the redirect response itself, with its
+  `Location`, instead of an opaque response.
+- `mode`, `credentials`, `cache` and the like do not apply; cookies are those
+  of the Go side's `http.Client` (give it a `Jar` to keep them).
+- Every response header is readable but `Set-Cookie`, which a `Response`
+  cannot hold.
+- URLs that are not http or https (the app's own pages, `data:`, `blob:`) go
+  to the webview's `fetch`.

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Makes an HTTP request from Go, with the options and result of the
+ * standard `fetch`. `mode`, `credentials`, `cache` and the like have no
+ * meaning there and are ignored; cookies are those of the Go side's
+ * `http.Client`. Response headers are all there but `Set-Cookie`.
+ */
+export declare function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+export default fetch;

package/dist/index.js

@@ -0,0 +1,142 @@
+// src/index.ts
+import { Channel, call, isCallError } from "mygo-runtime";
+var NULL_BODY = new Set([101, 103, 204, 205, 304]);
+var NORMALIZED = new Set(["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"]);
+async function fetch(input, init = {}) {
+  const req = typeof Request !== "undefined" && input instanceof Request ? input : null;
+  const base = typeof location !== "undefined" ? location.href : undefined;
+  const url = new URL(req ? req.url : input instanceof URL ? input.href : String(input), base);
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    return globalThis.fetch(input, init);
+  const signal = init.signal ?? req?.signal ?? null;
+  signal?.throwIfAborted();
+  let method = init.method ?? req?.method ?? "GET";
+  if (NORMALIZED.has(method.toUpperCase()))
+    method = method.toUpperCase();
+  const headers = new Headers(init.headers ?? req?.headers);
+  let body = null;
+  if (init.body != null) {
+    const r = new Response(init.body);
+    const type = r.headers.get("content-type");
+    if (type && !headers.has("content-type"))
+      headers.set("content-type", type);
+    body = new Uint8Array(await r.arrayBuffer());
+  } else if (init.body === undefined && req?.body) {
+    body = new Uint8Array(await req.arrayBuffer());
+  }
+  if (body && (method === "GET" || method === "HEAD")) {
+    throw new TypeError(`fetch: a ${method} request cannot have a body`);
+  }
+  const parts = new Channel;
+  const done = call("plugin:fetch.Fetch", {
+    url: url.href,
+    method,
+    headers: [...headers],
+    body: body && toBase64(body),
+    redirect: init.redirect ?? req?.redirect ?? "follow"
+  }, parts);
+  const failed = done.then(() => null, (err) => failure(err));
+  const it = parts[Symbol.asyncIterator]();
+  let stream;
+  let rejectHead;
+  const onAbort = () => {
+    parts.close();
+    try {
+      stream?.error(signal.reason);
+    } catch {}
+    rejectHead?.(signal.reason);
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const cleanup = () => signal?.removeEventListener("abort", onAbort);
+  let head;
+  try {
+    const first = await new Promise((resolve, reject) => {
+      rejectHead = reject;
+      it.next().then(resolve, reject);
+    });
+    rejectHead = undefined;
+    if (first.done)
+      throw await failed ?? new TypeError("fetch failed: no response");
+    head = first.value;
+  } catch (err) {
+    cleanup();
+    parts.close();
+    throw err;
+  }
+  const status = head.status ?? 200;
+  const nullBody = NULL_BODY.has(status) || method === "HEAD";
+  const readable = nullBody ? null : new ReadableStream({
+    start(controller) {
+      stream = controller;
+    },
+    async pull(controller) {
+      const next = await it.next();
+      if (signal?.aborted)
+        return;
+      if (!next.done) {
+        if (next.value.chunk)
+          controller.enqueue(fromBase64(next.value.chunk));
+        return;
+      }
+      cleanup();
+      const err = await failed;
+      if (err)
+        controller.error(err);
+      else
+        controller.close();
+    },
+    cancel() {
+      cleanup();
+      parts.close();
+    }
+  }, { highWaterMark: 0 });
+  if (nullBody) {
+    parts.close();
+    cleanup();
+  }
+  const valid = status >= 200 && status <= 599;
+  const res = new Response(readable, {
+    status: valid ? status : 200,
+    statusText: head.statusText ?? "",
+    headers: head.headers ?? []
+  });
+  const own = (name, value) => Object.defineProperty(res, name, { value, enumerable: true });
+  own("url", head.url ?? url.href);
+  own("redirected", head.redirected ?? false);
+  if (!valid)
+    own("status", status);
+  return res;
+}
+var src_default = fetch;
+function failure(err) {
+  if (!isCallError(err))
+    return err instanceof Error ? err : new TypeError(String(err));
+  if (err.message.includes("plugin is not used")) {
+    return new Error("@mygo-plugins/fetch: the Go side does not use the plugin: call mygo.Use(fetch.Plugin) before App.Run");
+  }
+  return new TypeError(`fetch failed: ${err.message}`, { cause: err });
+}
+function toBase64(bytes) {
+  const native = bytes.toBase64;
+  if (native)
+    return native.call(bytes);
+  let s = "";
+  for (let i = 0;i < bytes.length; i += 32768) {
+    s += String.fromCharCode.apply(null, bytes.subarray(i, i + 32768));
+  }
+  return btoa(s);
+}
+function fromBase64(s) {
+  const native = Uint8Array.fromBase64;
+  if (native)
+    return native(s);
+  const bin = atob(s);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0;i < bin.length; i++)
+    bytes[i] = bin.charCodeAt(i);
+  return bytes;
+}
+export {
+  src_default as default,
+  fetch
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@mygo-plugins/fetch",
+  "version": "0.1.8",
+  "description": "A fetch that makes HTTP requests from Go, for MyGo desktop apps",
+  "keywords": [
+    "mygo",
+    "desktop",
+    "webview",
+    "go",
+    "fetch"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/egoist/mygo.git",
+    "directory": "plugins/fetch"
+  },
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun run ../build.ts",
+    "test": "bun test"
+  },
+  "peerDependencies": {
+    "mygo-runtime": "^0.1.8"
+  },
+  "devDependencies": {
+    "mygo-runtime": "^0.1.8"
+  }
+}