@softfault/blacketjs 0.1.0

package/dist/index.js

@@ -0,0 +1,734 @@
+// src/http.ts
+class BlacketHttpError extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`Blacket request failed with status ${status}`);
+    this.name = "BlacketHttpError";
+    this.status = status;
+    this.body = body;
+  }
+}
+
+class BlacketHttp {
+  baseUrl;
+  cookie;
+  headers;
+  timeoutMs;
+  retry503;
+  fetchFn;
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? "https://blacket.org").replace(/\/+$/, "");
+    this.cookie = options.cookie;
+    this.headers = options.headers;
+    this.timeoutMs = options.timeoutMs ?? 1e4;
+    this.retry503 = options.retry503 ?? 2;
+    this.fetchFn = options.fetch ?? fetch;
+  }
+  async get(path) {
+    return this.request(path, { method: "GET" });
+  }
+  async post(path, body = {}) {
+    return this.request(path, { method: "POST", body });
+  }
+  async upload(path, file) {
+    const filename = file.name ?? "upload";
+    const contentType = file.type || "application/octet-stream";
+    const signedUpload = await this.post(path, { filename, contentType });
+    if (signedUpload.error || !signedUpload.data) {
+      return signedUpload;
+    }
+    const uploadResponse = await this.fetchFn(signedUpload.data.url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": contentType
+      },
+      body: file
+    });
+    if (!uploadResponse.ok) {
+      return {
+        error: true,
+        reason: "Upload failed",
+        status: uploadResponse.status
+      };
+    }
+    return {
+      error: false,
+      url: signedUpload.data.publicUrl
+    };
+  }
+  socketUrl(path = "/worker/socket") {
+    const url = new URL(path, `${this.baseUrl}/`);
+    url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+    return url.toString();
+  }
+  socketHeaders(headers) {
+    const socketHeaders = new Headers(this.headers);
+    new Headers(headers).forEach((value, key) => {
+      socketHeaders.set(key, value);
+    });
+    if (this.cookie) {
+      socketHeaders.set("Cookie", this.cookie);
+    }
+    return socketHeaders;
+  }
+  async request(path, options) {
+    let attempts = 0;
+    while (true) {
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const response = await this.fetchFn(this.url(path), {
+          method: options.method,
+          headers: this.requestHeaders(options),
+          body: options.body === undefined ? undefined : JSON.stringify(options.body),
+          signal: controller.signal
+        });
+        const data = await this.readBody(response);
+        if (response.status === 503 && attempts < this.retry503) {
+          attempts++;
+          await this.wait(2000);
+          continue;
+        }
+        if (!response.ok) {
+          if (this.isRecord(data)) {
+            return {
+              status: response.status,
+              ...data
+            };
+          }
+          throw new BlacketHttpError(response.status, data);
+        }
+        return data;
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+  }
+  requestHeaders(options) {
+    const headers = new Headers(this.headers);
+    headers.set("Accept", "application/json");
+    if (options.method === "POST") {
+      headers.set("Content-Type", "application/json");
+    }
+    new Headers(options.headers).forEach((value, key) => {
+      headers.set(key, value);
+    });
+    if (this.cookie) {
+      headers.set("Cookie", this.cookie);
+    }
+    return headers;
+  }
+  url(path) {
+    if (/^https?:\/\//.test(path)) {
+      return path;
+    }
+    return new URL(path, `${this.baseUrl}/`).toString();
+  }
+  async readBody(response) {
+    const text = await response.text();
+    if (!text) {
+      return {};
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+// src/socket.ts
+class BlacketSocket {
+  url;
+  listeners = new Map;
+  headers;
+  reconnect;
+  WebSocketImpl;
+  socket;
+  manuallyClosed = false;
+  constructor(url, options = {}) {
+    this.url = url;
+    this.headers = options.headers;
+    this.reconnect = options.reconnect ?? true;
+    this.WebSocketImpl = options.WebSocket ?? WebSocket;
+  }
+  connect() {
+    this.manuallyClosed = false;
+    this.socket = this.createWebSocket();
+    this.socket.onmessage = (event) => this.handleMessage(event.data);
+    this.socket.onclose = () => {
+      if (!this.manuallyClosed && this.reconnect) {
+        this.connect();
+      }
+    };
+    return this;
+  }
+  close(code, reason) {
+    this.manuallyClosed = true;
+    this.socket?.close(code, reason);
+  }
+  waitUntilOpen() {
+    if (!this.socket) {
+      throw new Error("Blacket socket is not created");
+    }
+    if (this.socket.readyState === this.WebSocketImpl.OPEN) {
+      return Promise.resolve();
+    }
+    if (this.socket.readyState !== this.WebSocketImpl.CONNECTING) {
+      throw new Error("Blacket socket is not connecting");
+    }
+    return new Promise((resolve, reject) => {
+      const socket = this.socket;
+      if (!socket) {
+        reject(new Error("Blacket socket is not created"));
+        return;
+      }
+      socket.addEventListener("open", () => resolve(), { once: true });
+      socket.addEventListener("error", () => reject(new Error("Blacket socket failed to open")), {
+        once: true
+      });
+    });
+  }
+  on(event, callback) {
+    const callbacks = this.listeners.get(event) ?? new Set;
+    callbacks.add(callback);
+    this.listeners.set(event, callbacks);
+    return () => this.off(event, callback);
+  }
+  off(event, callback) {
+    this.listeners.get(event)?.delete(callback);
+  }
+  emit(event, data) {
+    if (!this.socket || this.socket.readyState !== this.WebSocketImpl.OPEN) {
+      throw new Error("Blacket socket is not open");
+    }
+    const msg = data === undefined ? { event } : { event, data };
+    this.socket.send(JSON.stringify(msg));
+  }
+  handleMessage(raw) {
+    const message = this.parseMessage(raw);
+    const callbacks = this.listeners.get(message.event);
+    if (!callbacks) {
+      return;
+    }
+    for (const callback of callbacks) {
+      callback(message);
+    }
+  }
+  parseMessage(raw) {
+    if (typeof raw !== "string") {
+      throw new Error("Blacket socket received a non-string message");
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed.event) {
+      throw new Error("Blacket socket message is missing an event");
+    }
+    return {
+      data: {},
+      ...parsed,
+      event: parsed.event
+    };
+  }
+  createWebSocket() {
+    if (!this.headers) {
+      return new this.WebSocketImpl(this.url);
+    }
+    const WebSocketImpl = this.WebSocketImpl;
+    return new WebSocketImpl(this.url, { headers: this.headers });
+  }
+}
+
+// src/client.ts
+var pathValue = (value) => encodeURIComponent(String(value));
+
+class BlacketClient {
+  http;
+  data;
+  account;
+  users;
+  friends;
+  settings;
+  cosmetics;
+  store;
+  market;
+  clans;
+  trades;
+  messages;
+  socket;
+  constructor(options = {}) {
+    this.http = new BlacketHttp(options);
+    this.data = new BlacketData(this.http);
+    this.account = new BlacketAccount(this.http, () => this.currentSocket());
+    this.users = new BlacketUsers(this.http);
+    this.friends = new BlacketFriends(this.http, () => this.currentSocket());
+    this.settings = new BlacketSettings(this.http);
+    this.cosmetics = new BlacketCosmetics(this.http);
+    this.store = new BlacketStore(this.http);
+    this.market = new BlacketMarket(this.http, () => this.currentSocket());
+    this.clans = new BlacketClans(this.http, () => this.currentSocket());
+    this.trades = new BlacketTrades(this.http, () => this.currentSocket());
+    this.messages = new BlacketMessages(this.http, () => this.currentSocket());
+  }
+  get(path) {
+    return this.http.get(path);
+  }
+  post(path, body = {}) {
+    return this.http.post(path, body);
+  }
+  upload(path, file) {
+    return this.http.upload(path, file);
+  }
+  createSocket(options) {
+    this.socket = new BlacketSocket(this.http.socketUrl(), {
+      ...options,
+      headers: this.http.socketHeaders(options?.headers)
+    });
+    return this.socket;
+  }
+  connectSocket(options) {
+    return this.createSocket(options).connect();
+  }
+  useSocket(socket) {
+    this.socket = socket;
+    return this;
+  }
+  closeSocket(code, reason) {
+    this.currentSocket().close(code, reason);
+  }
+  onSocket(event, callback) {
+    return this.currentSocket().on(event, callback);
+  }
+  emitSocket(event, data) {
+    this.currentSocket().emit(event, data);
+  }
+  currentSocket() {
+    if (!this.socket) {
+      throw new Error("Blacket socket is not created. Call client.connectSocket() first");
+    }
+    return this.socket;
+  }
+}
+
+class BlacketData {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  index() {
+    return this.http.get("/data/index.json");
+  }
+  emojis() {
+    return this.http.get("/content/emojis.json");
+  }
+}
+
+class BlacketAccount {
+  http;
+  socket;
+  constructor(http, socket) {
+    this.http = http;
+    this.socket = socket;
+  }
+  currentUser() {
+    return this.http.get("/worker2/user");
+  }
+  claimDaily() {
+    return this.http.get("/worker/claim");
+  }
+  ping() {
+    return this.http.get("/worker/ping");
+  }
+  giveawaysSince(since) {
+    return this.http.get(`/worker/giveaways/since?since=${pathValue(since)}`);
+  }
+  markInboxRead(id) {
+    return this.http.post("/worker/inbox/read", { id });
+  }
+  status(body) {
+    return this.http.post("/worker/status", body);
+  }
+  upload(file) {
+    return this.http.upload("/worker/upload", file);
+  }
+  heartbeat() {
+    this.socket().emit("heartbeat");
+  }
+  replyToHeartbeat() {
+    return this.onHeartbeat(() => this.heartbeat());
+  }
+  onHeartbeat(callback) {
+    return this.socket().on("heartbeat", callback);
+  }
+  onNotification(callback) {
+    return this.socket().on("notification", callback);
+  }
+  onDestroySession(callback) {
+    return this.socket().on("destroy-session", callback);
+  }
+}
+
+class BlacketUsers {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  me() {
+    return this.http.get("/worker2/user");
+  }
+  get(user) {
+    return this.http.get(`/worker2/user/${pathValue(user)}`);
+  }
+  friends() {
+    return this.http.get("/worker2/friends");
+  }
+}
+
+class BlacketFriends {
+  http;
+  socket;
+  constructor(http, socket) {
+    this.http = http;
+    this.socket = socket;
+  }
+  request(user) {
+    return this.http.post("/worker/friends/request", { user });
+  }
+  remove(user) {
+    return this.http.post("/worker/friends/remove", { user });
+  }
+  block(user) {
+    return this.http.post("/worker/friends/block", { user });
+  }
+  unblock(user) {
+    return this.http.post("/worker/friends/unblock", { user });
+  }
+  cancel(user) {
+    return this.http.post("/worker/friends/cancel", { user });
+  }
+  accept(user) {
+    return this.http.post("/worker/friends/accept", { user });
+  }
+  decline(user) {
+    return this.http.post("/worker/friends/decline", { user });
+  }
+  onRequestReceived(callback) {
+    return this.socket().on("friends-requests-received", callback);
+  }
+  onRequestAccepted(callback) {
+    return this.socket().on("friends-requests-accepted", callback);
+  }
+  onRequestDeclined(callback) {
+    return this.socket().on("friends-requests-declined", callback);
+  }
+  onRequestCancelled(callback) {
+    return this.socket().on("friends-requests-cancelled", callback);
+  }
+  onRemoved(callback) {
+    return this.socket().on("friends-relationships-removed", callback);
+  }
+}
+
+class BlacketSettings {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  tradeRequests(value) {
+    return this.http.post("/worker/settings/requests", { value });
+  }
+  friendRequests(value) {
+    return this.http.post("/worker/settings/friends", { value });
+  }
+  username(username, password) {
+    return this.http.post("/worker/settings/username", { username, password });
+  }
+  password(oldPassword, newPassword) {
+    return this.http.post("/worker/settings/password", { oldPassword, newPassword });
+  }
+  generateOtp() {
+    return this.http.get("/worker/otp/generate");
+  }
+  enableOtp(code) {
+    return this.http.post("/worker/otp/enable", { code });
+  }
+  disableOtp(code) {
+    return this.http.post("/worker/otp/disable", { code });
+  }
+  color(color) {
+    return this.http.post("/worker/settings/color", { color });
+  }
+}
+
+class BlacketCosmetics {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  avatar(blook) {
+    return this.http.post("/worker/cosmetics/avatar", { blook });
+  }
+  banner(banner) {
+    return this.http.post("/worker/cosmetics/banner", { banner });
+  }
+}
+
+class BlacketStore {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  startPurchase(item, quantity, origin) {
+    return this.http.post("/worker/start-purchase", { item, quantity, origin });
+  }
+  legacyPurchase(item) {
+    return this.http.get(`/worker/purchase?item=${pathValue(item)}`);
+  }
+}
+
+class BlacketMarket {
+  http;
+  socket;
+  constructor(http, socket) {
+    this.http = http;
+    this.socket = socket;
+  }
+  openPack(pack) {
+    return this.http.post("/worker3/open", { pack });
+  }
+  buyShopItem(item) {
+    return this.http.post("/worker/shop/buy", { item });
+  }
+  onBazaarPurchase(callback) {
+    return this.socket().on("bazaar-purchase", callback);
+  }
+}
+
+class BlacketClans {
+  http;
+  socket;
+  constructor(http, socket) {
+    this.http = http;
+    this.socket = socket;
+  }
+  mine() {
+    return this.http.get("/worker/clans");
+  }
+  discoverPage(page) {
+    return this.http.get(`/worker/clans/discover/page/${pathValue(page)}`);
+  }
+  discoverByName(name) {
+    return this.http.get(`/worker/clans/discover/name/${pathValue(name)}`);
+  }
+  pendingRequests() {
+    return this.http.get("/worker/clans/requests/pending");
+  }
+  myPendingRequests() {
+    return this.http.get("/worker/clans/requests/pending/me");
+  }
+  sendRequest(clan) {
+    return this.http.post("/worker/clans/requests/send", { clan });
+  }
+  join(clan) {
+    return this.http.post("/worker/clans/join", { clan });
+  }
+  acceptRequest(user) {
+    return this.http.post("/worker/clans/requests/accept", { user });
+  }
+  rejectRequest(user) {
+    return this.http.post("/worker/clans/requests/reject", { user });
+  }
+  create(body) {
+    return this.http.post("/worker/clans/create", body);
+  }
+  leave(password, code) {
+    return this.http.post("/worker/clans/leave", { password, code });
+  }
+  kick(user) {
+    return this.http.post("/worker/clans/kick", { user });
+  }
+  ongoingEvents() {
+    return this.http.get("/worker/clans/events/ongoing");
+  }
+  addInvestment(tokens) {
+    return this.http.post("/worker/clans/investments/add", { tokens });
+  }
+  removeInvestment(tokens) {
+    return this.http.post("/worker/clans/investments/remove", { tokens });
+  }
+  upgradeInvestment() {
+    return this.http.post("/worker/clans/investments/upgrade", {});
+  }
+  addInventoryItem(item) {
+    return this.http.post("/worker/clans/inventory/add", { item });
+  }
+  removeInventoryItem(item) {
+    return this.http.post("/worker/clans/inventory/remove", { item });
+  }
+  useItem(item, clan) {
+    return this.http.post("/worker/use", { item, clan });
+  }
+  setName(name) {
+    return this.http.post("/worker/clans/settings/name", { name });
+  }
+  setDescription(description) {
+    return this.http.post("/worker/clans/settings/description", { description });
+  }
+  setImage(image) {
+    return this.http.post("/worker/clans/settings/image", { image });
+  }
+  resetColor() {
+    return this.http.post("/worker/clans/settings/reset-color", {});
+  }
+  toggleSafeMode() {
+    return this.http.post("/worker/clans/settings/safe-mode", {});
+  }
+  toggleRequests() {
+    return this.http.post("/worker/clans/settings/requests", {});
+  }
+  transferOwnership(user, password, code) {
+    return this.http.post("/worker/clans/settings/transfer-ownership", {
+      user,
+      password,
+      code
+    });
+  }
+  disband(password, code) {
+    return this.http.post("/worker/clans/settings/disband", { password, code });
+  }
+  robAttack() {
+    this.socket().emit("clans-attacks-rob");
+  }
+  onAttackStarted(callback) {
+    return this.socket().on("clans-attacks-started", callback);
+  }
+  onAttacked(callback) {
+    return this.socket().on("clans-attacks-attacked", callback);
+  }
+  onAttackAttempted(callback) {
+    return this.socket().on("clans-attacks-attempted", callback);
+  }
+  onAttackRob(callback) {
+    return this.socket().on("clans-attacks-rob", callback);
+  }
+}
+
+class BlacketTrades {
+  http;
+  socket;
+  constructor(http, socket) {
+    this.http = http;
+    this.socket = socket;
+  }
+  ongoing() {
+    return this.http.get("/worker/trades/ongoing");
+  }
+  sendRequest(user) {
+    return this.http.post("/worker/trades/requests/send", { user: String(user) });
+  }
+  cancelRequest() {
+    return this.http.post("/worker/trades/requests/cancel", {});
+  }
+  acceptRequest() {
+    return this.http.post("/worker/trades/requests/accept", {});
+  }
+  declineRequest() {
+    return this.http.post("/worker/trades/requests/decline", {});
+  }
+  onRequestReceived(callback) {
+    return this.socket().on("trading-requests-received", callback);
+  }
+  onRequestAccepted(callback) {
+    return this.socket().on("trading-requests-accepted", callback);
+  }
+  onRequestDeclined(callback) {
+    return this.socket().on("trading-requests-declined", callback);
+  }
+  onRequestCancelled(callback) {
+    return this.socket().on("trading-requests-cancelled", callback);
+  }
+  sendBlooks(blooks) {
+    this.socket().emit("trading-ongoing-blooks", blooks);
+  }
+  sendTokens(tokens) {
+    this.socket().emit("trading-ongoing-tokens", tokens);
+  }
+  acceptOngoing() {
+    this.socket().emit("trading-ongoing-accept");
+  }
+  cancelOngoing() {
+    this.socket().emit("trading-ongoing-cancel");
+  }
+  declineOngoing() {
+    this.socket().emit("trading-ongoing-decline");
+  }
+  onTokens(callback) {
+    return this.socket().on("trading-ongoing-tokens", callback);
+  }
+  onBlooks(callback) {
+    return this.socket().on("trading-ongoing-blooks", callback);
+  }
+  onAccepted(callback) {
+    return this.socket().on("trading-ongoing-accept", callback);
+  }
+  onCancelled(callback) {
+    return this.socket().on("trading-ongoing-cancel", callback);
+  }
+  onDeclined(callback) {
+    return this.socket().on("trading-ongoing-decline", callback);
+  }
+  onComplete(callback) {
+    return this.socket().on("trading-ongoing-complete", callback);
+  }
+}
+
+class BlacketMessages {
+  http;
+  socket;
+  constructor(http, socket) {
+    this.http = http;
+    this.socket = socket;
+  }
+  list(room, limit = 100) {
+    return this.http.get(`/worker2/messages/${pathValue(room)}?limit=${pathValue(limit)}`);
+  }
+  edit(message, content) {
+    return this.http.post(`/worker/messages/${pathValue(message)}/edit`, { content });
+  }
+  delete(message) {
+    return this.http.post(`/worker/messages/${pathValue(message)}/delete`, {});
+  }
+  reportMessage(message, reason) {
+    return this.http.post(`/worker/reports/messages/${pathValue(message)}/create`, {
+      reason
+    });
+  }
+  reportUser(user, reason) {
+    return this.http.post(`/worker/reports/users/${pathValue(user)}/create`, { reason });
+  }
+  async send(room, content) {
+    await this.socket().waitUntilOpen();
+    this.socket().emit("messages-create", { room, content });
+  }
+  onCreate(callback) {
+    return this.socket().on("messages-create", callback);
+  }
+  onEdit(callback) {
+    return this.socket().on("messages-edit", callback);
+  }
+  onDelete(callback) {
+    return this.socket().on("messages-delete", callback);
+  }
+}
+export {
+  BlacketSocket,
+  BlacketHttpError,
+  BlacketHttp,
+  BlacketClient
+};