revbot.js 0.0.13 → 0.0.15-build-test

package/dist/rest/CDNClient.d.cts

@@ -0,0 +1,10 @@
+export { a6 as CDNClient } from '../index-XkxTx7UU.cjs';
+import 'form-data';
+import 'revolt-api';
+import '../utils/badges.cjs';
+import '../utils/bitField.cjs';
+import '../utils/permissions.cjs';
+import '../utils/types.cjs';
+import 'node:buffer';
+import 'stream';
+import 'node:events';

package/dist/rest/CDNClient.d.ts

@@ -0,0 +1,10 @@
+export { a6 as CDNClient } from '../index-D44PqKGb.js';
+import 'form-data';
+import 'revolt-api';
+import '../utils/badges.js';
+import '../utils/bitField.js';
+import '../utils/permissions.js';
+import '../utils/types.js';
+import 'node:buffer';
+import 'stream';
+import 'node:events';

package/dist/rest/CDNClient.js

@@ -0,0 +1,16 @@
+import {
+  CDNClient
+} from "../chunk-HKLTWZSB.js";
+import "../chunk-HETUKFLM.js";
+import "../chunk-GNQQG7EP.js";
+import "../chunk-7XUN3OQT.js";
+import "../chunk-7PA5MDKS.js";
+import "../chunk-LY7OFI25.js";
+import "../chunk-LUDTY3LL.js";
+import "../chunk-CQ4AJZQD.js";
+import "../chunk-LAL23AQK.js";
+import "../chunk-ICANLKGX.js";
+export {
+  CDNClient
+};
+//# sourceMappingURL=CDNClient.js.map

package/dist/rest/CDNClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/rest/restClient.cjs

@@ -0,0 +1,652 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+
+// src/rest/restClient.ts
+var restClient_exports = {};
+__export(restClient_exports, {
+  RestClient: () => RestClient
+});
+module.exports = __toCommonJS(restClient_exports);
+var import_axios2 = require("axios");
+
+// src/utils/UUID.ts
+var import_crypto = require("crypto");
+var _UUID = class _UUID extends null {
+  static get PROG() {
+    return (0, import_crypto.randomBytes)(1).readUInt8() / 255;
+  }
+  static time(now = Date.now()) {
+    let mod, result = "";
+    for (let i = this.TIME_LENGTH; i > 0; i--) {
+      mod = now % this.ENCODING_LENGTH;
+      result = this.ENCODING.charAt(mod) + result;
+      now = (now - mod) / this.ENCODING_LENGTH;
+    }
+    return result;
+  }
+  static hash() {
+    let result = "";
+    for (let i = this.RANDOM_LENGTH; i > 0; i--) {
+      let random = Math.floor(this.PROG * this.ENCODING_LENGTH);
+      if (random === this.ENCODING_LENGTH) {
+        random = this.ENCODING_LENGTH - 1;
+      }
+      result = this.ENCODING.charAt(random) + result;
+    }
+    return result;
+  }
+  static generate(timestamp = Date.now()) {
+    return this.time(timestamp) + this.hash();
+  }
+  static timestampOf(id) {
+    const timestamp = id.slice(0, this.TIME_LENGTH).split("").reverse().reduce((carry, char, index) => {
+      const encodingIndex = this.ENCODING.indexOf(char);
+      if (encodingIndex === -1) {
+        throw new Error("invalid character found: " + char);
+      }
+      return carry += encodingIndex * Math.pow(this.ENCODING_LENGTH, index);
+    }, 0);
+    return new Date(timestamp);
+  }
+};
+_UUID.ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+_UUID.ENCODING_LENGTH = _UUID.ENCODING.length;
+_UUID.RANDOM_LENGTH = 16;
+_UUID.TIME_LENGTH = 10;
+_UUID.TIME_MAX = Math.pow(2, 48) - 1;
+var UUID = _UUID;
+
+// src/utils/bitField.ts
+var DEFAULT_BIT = 0;
+var _BitField = class _BitField {
+  constructor(bits = DEFAULT_BIT) {
+    this.bitfield = DEFAULT_BIT;
+    this.bitfield = this.self.resolve(bits);
+  }
+  /**
+   * Resolves a bitfield or an array of bitfields into a single number.
+   * @param bit The bitfield or array of bitfields to resolve.
+   * @returns The resolved bitfield as a number.
+   */
+  static resolve(bit) {
+    if (bit instanceof _BitField) return bit.bitfield;
+    if (typeof bit === "number" && bit >= DEFAULT_BIT) return bit;
+    if (Array.isArray(bit)) {
+      return bit.map((p) => this.resolve(p)).reduce((prev, p) => prev | p, DEFAULT_BIT);
+    }
+    if (typeof this.FLAGS[bit] !== "undefined") return this.FLAGS[bit];
+    throw new Error("BITFIELD_INVALID");
+  }
+  /**
+   * Returns the class that this instance belongs to.
+   * @returns The class of the bitfield.
+   */
+  get self() {
+    return this.constructor;
+  }
+  /**
+   * Checks if any of the bits in the bitfield are set.
+   * @param bit The bitfield or array of bitfields to check.
+   * @returns True if any bits are set, false otherwise.
+   */
+  any(bit) {
+    bit = this.self.resolve(bit);
+    return (this.bitfield & bit) !== DEFAULT_BIT;
+  }
+  /**
+   * checks if a specific permission is set.
+   */
+  has(bit) {
+    bit = this.self.resolve(bit);
+    return (this.bitfield & bit) === bit;
+  }
+  /**
+   * Returns an array of all the Permissions that are set in the bitfield.
+   * @returns An array of flag names.
+   */
+  toArray() {
+    return Object.keys(this.self.FLAGS).filter((bit) => this.has(bit));
+  }
+  add(...bits) {
+    let total = 0;
+    for (const bit of bits) {
+      total |= this.self.resolve(bit);
+    }
+    if (Object.isFrozen(this)) {
+      return new this.self(this.bitfield | total);
+    }
+    this.bitfield |= total;
+    return this;
+  }
+  remove(...bits) {
+    let total = 0;
+    for (const bit of bits) {
+      total |= this.self.resolve(bit);
+    }
+    if (Object.isFrozen(this)) {
+      return new this.self(this.bitfield & ~total);
+    }
+    this.bitfield &= ~total;
+    return this;
+  }
+  freeze() {
+    return Object.freeze(this);
+  }
+  valueOf() {
+    return this.bitfield;
+  }
+  /**
+   *
+   * @returns A record of all flags and their boolean values indicating whether they are set.
+   */
+  serialize() {
+    const serialized = {};
+    for (const [flag, bit] of Object.entries(this.self.FLAGS)) {
+      serialized[flag] = this.has(bit);
+    }
+    return serialized;
+  }
+  *[Symbol.iterator]() {
+    yield* __yieldStar(this.toArray());
+  }
+};
+_BitField.FLAGS = {};
+var BitField = _BitField;
+
+// src/utils/constants.ts
+var DEFAULT_CLIENT_OPTIONS = {
+  fetchMembers: true,
+  rest: {
+    timeout: 15e3,
+    retries: 3
+  },
+  ws: {
+    heartbeatInterval: 3e4,
+    reconnect: true
+  }
+};
+var apiUrl = "https://api.revolt.chat";
+var SYSTEM_USER_ID = "0".repeat(UUID.TIME_LENGTH + UUID.RANDOM_LENGTH);
+
+// src/utils/permissions.ts
+var ChannelPermissions = class extends BitField {
+  constructor(bits) {
+    super(bits);
+  }
+  static resolve(bit) {
+    return super.resolve(bit);
+  }
+};
+ChannelPermissions.FLAGS = {
+  VIEW_CHANNEL: __pow(1, 0),
+  SEND_MESSAGE: __pow(1, 22),
+  MANAGE_MESSAGE: __pow(1, 2),
+  MANAGE_CHANNEL: __pow(1, 3),
+  VOICE_CALL: __pow(1, 4),
+  INVITE_OTHERS: __pow(1, 5),
+  EMBED_LINKS: __pow(1, 6),
+  UPLOAD_FILES: __pow(1, 7)
+};
+var UserPermissions = class extends BitField {
+  constructor(bits) {
+    super(bits);
+  }
+  static resolve(bit) {
+    return super.resolve(bit);
+  }
+};
+UserPermissions.FLAGS = {
+  ACCESS: __pow(1, 0),
+  VIEW_PROFILE: __pow(1, 1),
+  SEND_MESSAGES: __pow(1, 2),
+  INVITE: __pow(1, 3)
+};
+var ServerPermissions = class extends BitField {
+  constructor(bits) {
+    super(bits);
+  }
+  static resolve(bit) {
+    return super.resolve(bit);
+  }
+};
+ServerPermissions.FLAGS = {
+  VIEW_SERVER: __pow(1, 0),
+  MANAGE_ROLES: __pow(1, 1),
+  MANAGE_CHANNELS: __pow(1, 2),
+  MANAGE_SERVER: __pow(1, 3),
+  KICK_MEMBERS: __pow(1, 4),
+  BAN_MEMBERS: __pow(1, 5),
+  CHANGE_NICKNAME: __pow(1, 12),
+  MANAGE_NICKNAMES: __pow(1, 13),
+  CHANGE_AVATAR: __pow(1, 14),
+  REMOVE_AVATARS: __pow(1, 15)
+};
+var FullPermissions = class extends BitField {
+  constructor(bits) {
+    super(bits);
+  }
+  static resolve(bit) {
+    return super.resolve(bit);
+  }
+};
+FullPermissions.FLAGS = {
+  // * Generic permissions
+  /// Manage the channel or channels on the server
+  ManageChannel: __pow(2, 0),
+  /// Manage the server
+  ManageServer: __pow(2, 1),
+  /// Manage permissions on servers or channels
+  ManagePermissions: __pow(2, 2),
+  /// Manage roles on server
+  ManageRole: __pow(2, 3),
+  /// Manage server customisation (includes emoji)
+  ManageCustomisation: __pow(2, 4),
+  // * Member permissions
+  /// Kick other members below their ranking
+  KickMembers: __pow(2, 6),
+  /// Ban other members below their ranking
+  BanMembers: __pow(2, 7),
+  /// Timeout other members below their ranking
+  TimeoutMembers: __pow(2, 8),
+  /// Assign roles to members below their ranking
+  AssignRoles: __pow(2, 9),
+  /// Change own nickname
+  ChangeNickname: __pow(2, 10),
+  /// Change or remove other's nicknames below their ranking
+  ManageNicknames: __pow(2, 11),
+  /// Change own avatar
+  ChangeAvatar: __pow(2, 12),
+  /// Remove other's avatars below their ranking
+  RemoveAvatars: __pow(2, 13),
+  // * Channel permissions
+  /// View a channel
+  ViewChannel: __pow(2, 20),
+  /// Read a channel's past message history
+  ReadMessageHistory: __pow(2, 21),
+  /// Send a message in a channel
+  SendMessage: __pow(2, 22),
+  /// Delete messages in a channel
+  ManageMessages: __pow(2, 23),
+  /// Manage webhook entries on a channel
+  ManageWebhooks: __pow(2, 24),
+  /// Create invites to this channel
+  InviteOthers: __pow(2, 25),
+  /// Send embedded content in this channel
+  SendEmbeds: __pow(2, 26),
+  /// Send attachments and media in this channel
+  UploadFiles: __pow(2, 27),
+  /// Masquerade messages using custom nickname and avatar
+  Masquerade: __pow(2, 28),
+  /// React to messages with emoji
+  React: __pow(2, 29),
+  // * Voice permissions
+  /// Connect to a voice channel
+  Connect: __pow(2, 30),
+  /// Speak in a voice call
+  Speak: __pow(2, 31),
+  /// Share video in a voice call
+  Video: __pow(2, 32),
+  /// Mute other members with lower ranking in a voice call
+  MuteMembers: __pow(2, 33),
+  /// Deafen other members with lower ranking in a voice call
+  DeafenMembers: __pow(2, 34),
+  /// Move members between voice channels
+  MoveMembers: __pow(2, 35),
+  // * Mention permissions
+  /// Mention @everyone or @online
+  MentionEveryone: __pow(2, 37),
+  /// Mention a role
+  MentionRoles: __pow(2, 38),
+  // * Grant all permissions
+  /// Safely grant all permissions
+  GrantAll: 4503599627370495
+};
+var DEFAULT_PERMISSION_DM = new ChannelPermissions([
+  "VIEW_CHANNEL",
+  "VIEW_CHANNEL",
+  "MANAGE_CHANNEL",
+  "VOICE_CALL",
+  "EMBED_LINKS",
+  "UPLOAD_FILES"
+]).freeze();
+
+// src/utils/badges.ts
+var Badges = class extends BitField {
+  constructor(bits) {
+    super(bits);
+  }
+  static resolve(bit) {
+    return super.resolve(bit);
+  }
+};
+Badges.FLAGS = {
+  DEVELOPER: 1 << 0,
+  TRANSLATOR: 1 << 1,
+  SUPPORTER: 1 << 2,
+  RESPONSIBLE_DISCLOSURE: 1 << 3,
+  REVOLT_TEAM: 1 << 4,
+  EARLY_ADOPTER: 1 << 8
+};
+
+// package.json
+var version = "0.0.15-build-test";
+
+// src/rest/restUtils/rateLimitQueue.ts
+var import_axios = __toESM(require("axios"), 1);
+var RateLimitQueue = class {
+  constructor() {
+    this.bucketMap = /* @__PURE__ */ new Map();
+    this.pathToBucket = /* @__PURE__ */ new Map();
+  }
+  request(config) {
+    return __async(this, null, function* () {
+      const path = config.url;
+      const bucketId = this.pathToBucket.get(path);
+      let bucket = bucketId ? this.bucketMap.get(bucketId) : void 0;
+      if (bucket && bucket.remaining <= 0 && Date.now() < bucket.resetAfter) {
+        return new Promise((resolve, reject) => {
+          bucket.queue.push(() => __async(this, null, function* () {
+            try {
+              const res = yield this._doRequest(config, path);
+              resolve(res);
+            } catch (e) {
+              reject(e);
+            }
+          }));
+        });
+      } else {
+        return this._doRequest(config, path);
+      }
+    });
+  }
+  _doRequest(config, path) {
+    return __async(this, null, function* () {
+      const response = yield (0, import_axios.default)(config);
+      this._updateRateLimit(path, response);
+      return response;
+    });
+  }
+  _updateRateLimit(path, response) {
+    const headers = response.headers;
+    const limit = parseInt(headers["x-ratelimit-limit"]);
+    const remaining = parseInt(headers["x-ratelimit-remaining"]);
+    const resetAfter = parseFloat(headers["x-ratelimit-reset-after"]) * 1e3 + Date.now();
+    const bucket = headers["x-ratelimit-bucket"];
+    const resetIn = parseInt(headers["x-ratelimit-reset-after"]);
+    if (!bucket) return;
+    this.pathToBucket.set(path, bucket);
+    let state = this.bucketMap.get(bucket);
+    if (!state) {
+      state = {
+        limit,
+        remaining,
+        resetAfter,
+        bucket,
+        resetIn,
+        queue: [],
+        lastPath: path
+      };
+      this.bucketMap.set(bucket, state);
+    } else {
+      state.limit = limit;
+      state.remaining = remaining;
+      state.resetAfter = resetAfter;
+      state.lastPath = path;
+    }
+    if (remaining <= 0) {
+      if (state.resetTimeout) clearTimeout(state.resetTimeout);
+      const delay = resetIn;
+      state.resetTimeout = setTimeout(() => {
+        state.remaining = state.limit;
+        state.resetTimeout = void 0;
+        while (state.queue.length > 0 && state.remaining > 0) {
+          const fn = state.queue.shift();
+          if (fn) {
+            state.remaining--;
+            fn();
+          }
+        }
+      }, delay);
+    }
+  }
+};
+
+// src/rest/restClient.ts
+var RestClient = class {
+  constructor(client) {
+    this.client = client;
+    this.rateLimitQueue = new RateLimitQueue();
+  }
+  /**
+   * Helper function to handle API requests.
+   * @param method The HTTP method (GET, POST, PATCH, PUT, DELETE).
+   * @param url The URL for the request.
+   * @param body The request body (if applicable).
+   * @param query Query parameters (if applicable).
+   * @returns The API response.
+   */
+  request(method, url, body, query, retry) {
+    return __async(this, null, function* () {
+      var _a;
+      try {
+        if (!this.client.token) throw new Error("Token is required");
+        const authHeader = this.client.bot ? "X-Bot-Token" : "X-Session-Token";
+        const config = __spreadProps(__spreadValues({}, {
+          method,
+          url: `${apiUrl}${url}`,
+          params: query,
+          data: body == null ? void 0 : body.body,
+          headers: {
+            [authHeader]: this.client.token,
+            "User-Agent": `RevBot.js/${version}`
+          }
+        }), {
+          url: `${apiUrl}${url}`
+        });
+        const response = yield this.rateLimitQueue.request(config);
+        return response.data;
+      } catch (error) {
+        if (retry) throw typeof error;
+        if (error instanceof import_axios2.AxiosError) {
+          if (error.status && (error.status === 429 || error.status >= 500)) {
+            return this.retryRequest(0, method, url, body, query);
+          }
+          if (error.status) {
+            throw new Error(
+              `API call failed with status ${error.status}: ${(_a = error.response) == null ? void 0 : _a.statusText}`
+            );
+          }
+        }
+        throw new Error(
+          `API call failed: ${error instanceof Error ? error.message : error}`
+        );
+      }
+    });
+  }
+  retryRequest(attempt = 0, method, url, body, query) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (attempt >= ((_b = (_a = this.client.options.rest) == null ? void 0 : _a.retries) != null ? _b : 3)) {
+        throw new Error("Max retries reached");
+      }
+      try {
+        return yield this.request(method, url, body, query, true);
+      } catch (error) {
+        console.warn(`Attempt ${attempt + 1} failed:`, error);
+        yield new Promise(
+          (resolve) => {
+            var _a2, _b2, _c;
+            return setTimeout(
+              resolve,
+              (_c = (_a2 = this.client.options.rest) == null ? void 0 : _a2.timeout) != null ? _c : (_b2 = DEFAULT_CLIENT_OPTIONS.rest) == null ? void 0 : _b2.timeout
+            );
+          }
+        );
+        return this.retryRequest(attempt + 1, method, url, body, query);
+      }
+    });
+  }
+  /**
+   * GET request.
+   * @param url The URL for the request.
+   * @param query Query parameters (if applicable).
+   * @returns The API response.
+   */
+  get(url, query) {
+    return __async(this, null, function* () {
+      return this.request("GET", url, void 0, query);
+    });
+  }
+  /**
+   * POST request.
+   * @param url The URL for the request.
+   * @param body The request body.
+   * @param query Query parameters (if applicable).
+   * @returns The API response.
+   */
+  post(url, body, query) {
+    return __async(this, null, function* () {
+      return this.request("POST", url, body, query);
+    });
+  }
+  /**
+   * PATCH request.
+   * @param url The URL for the request.
+   * @param body The request body.
+   * @param query Query parameters (if applicable).
+   * @returns The API response.
+   */
+  patch(url, body, query) {
+    return __async(this, null, function* () {
+      return this.request("PATCH", url, body, query);
+    });
+  }
+  /**
+   * PUT request.
+   * @param url The URL for the request.
+   * @param body The request body.
+   * @param query Query parameters (if applicable).
+   * @returns The API response.
+   */
+  put(url, body, query) {
+    return __async(this, null, function* () {
+      return this.request("PUT", url, body, query);
+    });
+  }
+  /**
+   * DELETE request.
+   * @param url The URL for the request.
+   * @param query Query parameters (if applicable).
+   * @returns The API response.
+   */
+  delete(url, body, query) {
+    return __async(this, null, function* () {
+      return this.request("DELETE", url, body, query);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RestClient
+});
+//# sourceMappingURL=restClient.cjs.map