reconnectedchat
Version:
Framework for the ReconnectedCC Chatbox v2
231 lines • 8.86 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Client = void 0;
const events = __importStar(require("events"));
const constants = __importStar(require("./constants"));
const ws_1 = __importDefault(require("ws"));
const ChatboxError_1 = __importDefault(require("./errors/ChatboxError"));
class Client extends events.EventEmitter {
constructor(token, options) {
var _a, _b;
super();
this.owner = "Guest";
this.players = [];
this.endpoint = constants.endpoint;
this.defaultFormattingMode = "markdown";
this.waitTimeRestart = 60000;
this.running = false;
this._delay = 500;
this._queue = [];
this._awaitingQueue = {};
this._processingQueue = false;
this._queueCounter = 1;
this.capabilities = [];
this._token = token;
if (options) {
this.defaultName = (_a = options.defaultName) !== null && _a !== void 0 ? _a : this.defaultName;
this.defaultFormattingMode = (_b = options.defaultFormattingMode) !== null && _b !== void 0 ? _b : this.defaultFormattingMode;
}
this.on("afk", e => this.updatePlayer(e.user));
this.on("afk_return", e => this.updatePlayer(e.user));
}
updatePlayer(player) {
const existing = this.players.find((p) => p.uuid === player.uuid);
if (existing) {
Object.assign(existing, player);
}
else {
this.players.push(player);
}
}
say(text, name, mode = this.defaultFormattingMode) {
return new Promise((resolve, reject) => {
name = name !== null && name !== void 0 ? name : this.defaultName;
this._queue.push({
data: {
id: this._queueCounter++,
type: "say",
text: text,
name: name,
mode: mode,
},
resolve: resolve,
reject: reject,
});
this._processQueue();
});
}
tell(user, text, name, mode = this.defaultFormattingMode) {
return new Promise((resolve, reject) => {
name = name !== null && name !== void 0 ? name : this.defaultName;
let playerUsername;
if (typeof user === "string") {
playerUsername = user;
}
else {
playerUsername = user.name;
}
this._queue.push({
data: {
id: this._queueCounter++,
type: "tell",
user: playerUsername,
text: text,
name: name,
mode: mode,
},
resolve: resolve,
reject: reject,
});
this._processQueue();
});
}
connect(callback) {
this._ws = new ws_1.default(this.endpoint + this._token);
this._ws.on("close", (code, reason) => {
if (this.running) {
this._processingQueue = false;
this.reconnect(true);
}
});
this._ws.on("error", (err) => this.emit("ws_error", err));
this._ws.on("message", this._onMessage.bind(this));
if (callback) {
this._ws.on("open", () => callback(this));
}
}
close(soft) {
if (!soft) {
this.running = false;
}
this._processingQueue = false;
if (this._ws && (this._ws.readyState === this._ws.OPEN || this._ws.readyState === this._ws.CONNECTING)) {
this._ws.close();
}
}
reconnect(wait = false) {
this.close(true);
setTimeout(this.connect.bind(this), wait ? this.waitTimeRestart : 0);
}
_onReady() {
this._processQueue();
this.emit("ready");
}
_onMessage(rawData) {
const data = JSON.parse(rawData);
this.emit("raw", data);
switch (data.type) {
case "hello":
let hello = data;
this.running = true;
this.owner = hello.licenseOwner;
this.capabilities = hello.capabilities;
this._onReady();
break;
case "players":
let playersData = data;
this.players = playersData.players;
this.emit("players", this.players);
break;
case "event":
let event = data;
event.time = new Date(event.time);
if (event.type === "server_restart_scheduled") {
const restart = event;
restart.restartAt = new Date(restart.restartAt);
}
this._handleEvent(event);
break;
case "error":
let error = data;
if (error.id && this._awaitingQueue[error.id]) {
let promise = this._awaitingQueue[error.id];
let chatboxError = new ChatboxError_1.default(error.message, error.error, error.id);
promise.reject(chatboxError);
delete this._awaitingQueue[error.id];
}
break;
case "success":
let success = data;
let promise = this._awaitingQueue[success.id];
if (promise && success.reason === "message_sent") {
promise.resolve(success);
delete this._awaitingQueue[success.id];
}
break;
case "closing":
let closing = data;
this.emit("closing", closing);
this._processingQueue = false;
// server is shutting down, and we need to restart the connection
if (closing.closeReason !== "server_stopping") {
this.running = false;
}
}
}
_handleEvent(event) {
this.emit(event.event, event);
}
_processQueue() {
var _a;
return __awaiter(this, void 0, void 0, function* () {
if (this._processingQueue)
return;
this._processingQueue = true;
while (this._processingQueue) {
const data = this._queue.shift();
if (data) {
(_a = this._ws) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify(data.data));
this._awaitingQueue[data.data.id] = data;
yield this._sleep(this._delay);
}
else {
break;
}
}
this._processingQueue = false;
});
}
_sleep(ms) {
return new Promise(resolve => {
setTimeout(resolve, ms);
});
}
}
exports.Client = Client;
//# sourceMappingURL=Client.js.map