dredless 0.4.0 → 0.5.0

package/docs/API_REFERENCE.md

@@ -60,16 +60,13 @@ Both runtime entrypoints re-export world/model classes, protocol builders, confi
 
 ### `Server`
 
-Returned by `fetchServers()`.
+Returned by `fetchServers()`. Player counts and ping are returned separately by `fetchServerStatus()` or `fetchServerStatuses()`.
 
 ```ts
 interface Server {
   index: number;
   domain: string;
   description: string;
-  playerCount: number;
-  maxPlayerCount: number;
-  ping: number | null;
 }
 ```
 

package/docs/BROWSER_API.md

@@ -41,6 +41,8 @@ interface DredlessBrowserNamespace {
   fetchNoticeVersion: typeof fetchNoticeVersion;
   fetchGameVersion: typeof fetchGameVersion;
   fetchServers: typeof fetchServers;
+  fetchServerStatus: typeof fetchServerStatus;
+  fetchServerStatuses: typeof fetchServerStatuses;
   fetchShips: typeof fetchShips;
   fetchShipList: typeof fetchShipList;
   joinShip: typeof joinShip;

package/docs/NODE_API.md

@@ -108,7 +108,22 @@ Scrapes the current game version string from the site.
 function fetchServers(): Promise<Server[]>;
 ```
 
-Scrapes and returns known game servers.
+Scrapes and returns game servers.
+### `Dredless.fetchServerStatus(server)`
+
+```ts
+function fetchServerStatus(server: ServerRef): Promise<{ playerCount: number; maxPlayerCount: number; ping: number }>;
+```
+
+Pings the server and returns the current player counts and measured response time in milliseconds.
+
+### `Dredless.fetchServerStatuses()`
+
+```ts
+function fetchServerStatuses(): Promise<Server[]>;
+```
+
+Fetches status for every server and returns server objects with updated `playerCount`, `maxPlayerCount`, and `ping` fields.
 
 ### `Dredless.fetchShips(session, server)`
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dredless",
-    "version": "0.4.0",
+    "version": "0.5.0",
     "description": "A fully-featured and from-scratch headless drednot.io client implementation written in pure js.",
     "license": "MIT",
     "homepage": "https://github.com/certainhuman/dredless#readme",

package/src/browser.d.ts

@@ -76,6 +76,8 @@ export {
     decompressLz4Frame,
     fetchNoticeVersion,
     fetchGameVersion,
+    fetchServerStatus,
+    fetchServerStatuses,
     fetchServers
 } from "./index.js";
 
@@ -199,7 +201,7 @@ export interface DredlessBrowserNamespace {
     fetchAccountStatus: typeof fetchAccountStatus;
     fetchNoticeVersion: typeof import("./index.js").fetchNoticeVersion;
     fetchGameVersion: typeof import("./index.js").fetchGameVersion;
-    fetchServers: typeof import("./index.js").fetchServers;
+    fetchServers: typeof import("./index.js").fetchServers;`r`n    fetchServerStatus: typeof import("./index.js").fetchServerStatus;`r`n    fetchServerStatuses: typeof import("./index.js").fetchServerStatuses;
     fetchShips: typeof fetchShips;
     fetchShipList: typeof fetchShipList;
     joinShip: typeof joinShip;

package/src/browser.js

@@ -66,7 +66,7 @@ export {
 } from "./protocol/outbound/ui-config.js";
 export {decryptPayload} from "./crypto/chacha.js";
 export {decompressLz4Frame} from "./compression/lz4.js";
-export {fetchNoticeVersion, fetchGameVersion, fetchServers} from "./network/servers.js";
+export {fetchNoticeVersion, fetchGameVersion, fetchServerStatus, fetchServerStatuses, fetchServers} from "./network/servers.js";
 export {fetchShips as fetchShipsWithSession, fetchShipList as fetchShipListWithSession} from "./network/ships.js";
 export {
     BrowserSession,
@@ -88,7 +88,7 @@ export {
 
 import {Connection} from "./network/connection.js";
 import {DredlessClient} from "./client/index.js";
-import {fetchGameVersion, fetchNoticeVersion, fetchServers} from "./network/servers.js";
+import {fetchGameVersion, fetchNoticeVersion, fetchServerStatus, fetchServerStatuses, fetchServers} from "./network/servers.js";
 import {
     BrowserSession,
     browserSession,
@@ -121,6 +121,8 @@ export const DredlessBrowser = {
     fetchAccountStatus,
     fetchNoticeVersion,
     fetchGameVersion,
+    fetchServerStatus,
+    fetchServerStatuses,
     fetchServers,
     fetchShips,
     fetchShipList: fetchShipListForBrowser,

package/src/index.d.ts

@@ -2,9 +2,6 @@ export interface Server {
     index: number;
     domain: string;
     description: string;
-    playerCount: number;
-    maxPlayerCount: number;
-    ping: number | null;
 }
 
 export interface Ship {
@@ -31,6 +28,12 @@ export type ShipSpec =
     | { type: "new"; name?: string | null; color?: string | null }
     | { type: "invite"; code: string };
 
+export interface ServerStatus {
+    playerCount: number;
+    maxPlayerCount: number;
+    ping: number;
+}
+
 export type ServerRef = number | Server;
 export type ShipRef = number | string | Ship | ShipSpec | null;
 export type ShipPrivacy = 0 | 1 | boolean | "public" | "private";
@@ -2248,6 +2251,10 @@ export function fetchGameVersion(): Promise<string>;
 
 export function fetchServers(): Promise<Server[]>;
 
+export function fetchServerStatus(server: ServerRef): Promise<ServerStatus>;
+
+export function fetchServerStatuses(): Promise<(Server & ServerStatus)[]>;
+
 export function fetchShips(session: Session, server: ServerRef): Promise<Ship[]>;
 
 export function fetchShipList(session: Session, server: ServerRef): Promise<ShipList>;
@@ -2273,6 +2280,8 @@ export interface DredlessNamespace {
     fetchNoticeVersion: typeof fetchNoticeVersion;
     fetchGameVersion: typeof fetchGameVersion;
     fetchServers: typeof fetchServers;
+    fetchServerStatus: typeof fetchServerStatus;
+    fetchServerStatuses: typeof fetchServerStatuses;
     fetchShips: typeof fetchShips;
     fetchShipList: typeof fetchShipList;
     joinShip: typeof joinShip;
@@ -2280,6 +2289,5 @@ export interface DredlessNamespace {
     startNewShip: typeof startNewShip;
     joinInvite: typeof joinInvite;
 }
-
 export const Dredless: DredlessNamespace;
 export default Dredless;

package/src/index.js

@@ -81,7 +81,7 @@ export {decompressLz4Frame} from "./compression/lz4.js";
 import {AnonSession, createAnonSession, createAnonToken, createSession, Session} from "./network/session.js";
 import {Connection} from "./network/connection.js";
 import {DredlessClient} from "./client/index.js";
-import {fetchGameVersion, fetchNoticeVersion, fetchServers} from "./network/servers.js";
+import {fetchGameVersion, fetchNoticeVersion, fetchServerStatus, fetchServerStatuses, fetchServers} from "./network/servers.js";
 import {fetchShipList, fetchShips} from "./network/ships.js";
 
 async function sessionOrAnon(session) {
@@ -114,6 +114,8 @@ export const Dredless = {
     createAnonToken,
     fetchNoticeVersion,
     fetchGameVersion,
+    fetchServerStatus,
+    fetchServerStatuses,
     fetchServers,
     fetchShips,
     fetchShipList,

package/src/network/index.js

@@ -1,4 +1,4 @@
 export {Connection} from "./connection.js";
-export {fetchGameVersion, fetchNoticeVersion, fetchServers, resolveServer} from "./servers.js";
+export {fetchGameVersion, fetchNoticeVersion, fetchServerStatus, fetchServerStatuses, fetchServers, resolveServer} from "./servers.js";
 export {fetchShips, fetchShipList, createShipSpec, createInviteShipSpec, shipRef} from "./ships.js";
 export {Session, AnonSession, createSession, createAnonSession, createAnonToken} from "./session.js";

package/src/network/servers.d.ts

@@ -1,6 +1,8 @@
 export {
     fetchNoticeVersion,
     fetchGameVersion,
+    fetchServerStatus,
+    fetchServerStatuses,
     fetchServers,
     type Server,
     type ServerRef

package/src/network/servers.js

@@ -1,5 +1,5 @@
 import {DEFAULT_BASE_URL} from "../constants.js";
-import {hostName, normalizeBaseUrl} from "../runtime.js";
+import {getWebSocket, hostName, normalizeBaseUrl} from "../runtime.js";
 import {HttpClient} from "./http.js";
 
 const cache = new Map();
@@ -56,6 +56,56 @@ class ServerDirectory {
 
 export const fetchGameVersion = (baseUrl = DEFAULT_BASE_URL) => new ServerDirectory(baseUrl).version();
 export const fetchServers = (baseUrl = DEFAULT_BASE_URL) => new ServerDirectory(baseUrl).servers();
+export async function fetchServerStatus(server, baseUrl = DEFAULT_BASE_URL) {
+    const resolved = await resolveServer(server, baseUrl);
+    if (!resolved?.domain) throw new Error(`Unable to resolve server ${serverId(server)}`);
+    const WebSocket = await getWebSocket();
+    const startedAt = Date.now();
+    const socket = new WebSocket(`wss://${resolved.domain}:4000/`);
+
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (callback, value) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            callback(value);
+            if (socket.readyState === 0 || socket.readyState === 1) socket.close();
+        };
+        const timeout = setTimeout(() => finish(reject, new Error(`Timed out fetching status for ${resolved.domain}`)), 10000);
+        const onOpen = () => socket.send("yo");
+        const onMessage = async (event) => {
+            try {
+                const data = JSON.parse(await websocketText(event?.data ?? event));
+                const playerCount = Number(data.player_count);
+                const maxPlayerCount = Number(data.player_max);
+                if (!Number.isFinite(playerCount) || !Number.isFinite(maxPlayerCount)) throw new Error("Invalid server status response");
+                finish(resolve, {playerCount, maxPlayerCount, ping: Date.now() - startedAt});
+            } catch (error) {
+                finish(reject, new Error(`Invalid status response from ${resolved.domain}: ${error.message}`));
+            }
+        };
+        const onError = (event) => finish(reject, event?.error || new Error(`WebSocket error while fetching ${resolved.domain}`));
+        if (typeof socket.on === "function") {
+            socket.on("open", onOpen);
+            socket.on("message", onMessage);
+            socket.on("error", onError);
+        } else if (typeof socket.addEventListener === "function") {
+            socket.addEventListener("open", onOpen);
+            socket.addEventListener("message", onMessage);
+            socket.addEventListener("error", onError);
+        } else {
+            socket.onopen = onOpen;
+            socket.onmessage = onMessage;
+            socket.onerror = onError;
+        }
+    });
+}
+
+export async function fetchServerStatuses(baseUrl = DEFAULT_BASE_URL) {
+    const servers = await fetchServers(baseUrl);
+    return Promise.all(servers.map(async (server) => ({...server, ...await fetchServerStatus(server, baseUrl)})));
+}
 
 export async function fetchNoticeVersion(baseUrl = DEFAULT_BASE_URL) {
     const response = await new HttpClient({baseUrl}).request("index.html");
@@ -128,6 +178,13 @@ function parseServerInfo(text, baseUrl) {
     };
 }
 
+async function websocketText(data) {
+    if (typeof data === "string") return data;
+    if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+    if (ArrayBuffer.isView(data)) return new TextDecoder().decode(data);
+    if (typeof data?.text === "function") return data.text();
+    return String(data);
+}
 function server(index, domain, description) {
-    return {index, domain, description, playerCount: 0, maxPlayerCount: 0, ping: null};
+    return {index, domain, description};
 }