Networking

// all global - no import, no permission in the manifest
const data = await (await fetch("https://httpbin.org/json")).json();
const socket = new WebSocket("wss://ws.postman-echo.com/raw");

const res = await fetch("https://httpbin.org/get");
console.log(res.status, res.ok);            // 200 true

// POST JSON
await fetch("https://httpbin.org/post", {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ kills: 12, map: "de_dust2" }),
});

// query string - let URL build it
const url = new URL("https://httpbin.org/get");
url.searchParams.set("player", "spurdo");
await fetch(url);

const form = new FormData();
form.append("map", currentMap());
form.append("shot", new Blob([pngBytes], { type: "image/png" }), "shot.png");

await fetch("https://example.com/upload", { method: "POST", body: form });

const res = await fetch("https://httpbin.org/stream-bytes/1048576");
const total = Number(res.headers.get("content-length") ?? 0);

let received = 0;
for await (const chunk of res.body) {
    received += chunk.length;
    if (total) console.log(`${((received / total) * 100) | 0}%`);
}

// cancel by hand
const controller = new AbortController();
setTimeout(() => controller.abort(), 2_000);
await fetch(url, { signal: controller.signal });

// or give it a deadline
await fetch(url, { signal: AbortSignal.timeout(5_000) });

// or both
await fetch(url, { signal: AbortSignal.any([controller.signal, AbortSignal.timeout(5_000)]) });

const hop = await fetch(url, { redirect: "manual" });
console.log(hop.status, hop.headers.get("location"));

await (await fetch("data:text/plain;base64,aGVsbG8=")).text();   // "hello"

const objectUrl = URL.createObjectURL(new Blob([bytes], { type: "image/png" }));
const png = await (await fetch(objectUrl)).bytes();
URL.revokeObjectURL(objectUrl);

const socket = new WebSocket("wss://ws.postman-echo.com/raw");

socket.onopen    = () => socket.send("hello");
socket.onmessage = (e) => console.log("got", e.data);
socket.onclose   = (e) => console.log(`closed ${e.code} ${e.reason} clean=${e.wasClean}`);
socket.onerror   = () => console.log("socket error");

const socket = new WebSocket("wss://example.com/stream", ["json.v2", "json.v1"]);
socket.binaryType = "arraybuffer";          // or "blob"

socket.onopen = () => {
    console.log("agreed on", socket.protocol);   // whichever the server picked
    socket.send(new Uint8Array([1, 2, 3]));      // strings, buffers, views, Blobs
    console.log(socket.bufferedAmount);          // bytes still queued
};

socket.close(1000, "done");    // only 1000 and 3000-4999 may be sent

function connect(url, onMessage) {
    let delay = 500;

    const open = () => {
        const socket = new WebSocket(url);

        socket.onopen    = () => { delay = 500; };
        socket.onmessage = (e) => onMessage(e.data);
        socket.onclose   = () => {
            setTimeout(open, delay);
            delay = Math.min(delay * 2, 30_000);   // back off, then keep trying
        };
    };

    open();
}

const events = new EventSource("https://example.com/stream");

events.onopen    = () => console.log("streaming");
events.onmessage = (e) => console.log(e.data, e.lastEventId);
events.onerror   = () => console.log(`dropped, retrying (state ${events.readyState})`);

// named events, as sent by `event: score`
events.addEventListener("score", (e) => console.log(JSON.parse(e.data)));

events.close();

import axios from "axios";        // picks its XHR adapter on its own
const { data } = await axios.get("https://httpbin.org/json", { timeout: 5_000 });

Failed to fetch: expired.badssl.com could not be trusted: the certificate has expired

const BASE = "https://api.example.com";

async function api(path, { method = "GET", body, token, timeoutMs = 10_000 } = {}) {
    const res = await fetch(`${BASE}${path}`, {
        method,
        headers: {
            accept: "application/json",
            ...(body  ? { "content-type": "application/json" } : {}),
            ...(token ? { authorization: `Bearer ${token}` } : {}),
        },
        body: body ? JSON.stringify(body) : undefined,
        signal: AbortSignal.timeout(timeoutMs),
    });

    if (!res.ok)
        throw new Error(`${method} ${path} -> ${res.status} ${(await res.text()).slice(0, 200)}`);

    return res.status === 204 ? null : res.json();
}

await api("/v1/stats", { method: "POST", body: { kills: 12 }, token });

async function fetchRetry(url, init = {}, attempts = 3) {
    let lastError;

    for (let attempt = 0; attempt < attempts; attempt++) {
        try {
            const res = await fetch(url, init);
            if (res.status >= 500 || res.status === 429) throw new Error(`http ${res.status}`);
            return res;
        } catch (err) {
            if (err.name === "AbortError") throw err;    // a cancel is not worth retrying
            lastError = err;
            await new Promise(r => setTimeout(r, 250 * 2 ** attempt));
        }
    }

    throw lastError;
}

import fs from "@native/fs";      // requires the "filesystem" permission - see /api/fs

const res = await fetch("https://example.com/model.bin");
const total = Number(res.headers.get("content-length") ?? 0);
const parts = [];
let received = 0;

for await (const chunk of res.body) {
    parts.push(chunk);
    received += chunk.length;
    if (total) console.log(`${((received / total) * 100) | 0}%`);
}

const out = new Uint8Array(received);
let offset = 0;
for (const part of parts) { out.set(part, offset); offset += part.length; }

await fs.writeFile("cache/model.bin", out);

try {
    const res = await fetch(url, { signal: AbortSignal.timeout(5_000) });
    if (!res.ok) return { error: `http ${res.status}` };
    return { data: await res.json() };
} catch (err) {
    if (err.name === "TimeoutError") return { error: "too slow" };
    if (err.name === "AbortError")   return { error: "cancelled" };
    return { error: String(err.message ?? err) };
}