@colyseus/core/build/utils/DevMode.cjs

Multiplayer Framework for Node.js.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
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);

// packages/core/src/utils/DevMode.ts
var DevMode_exports = {};
__export(DevMode_exports, {
  cacheRoomHistory: () => cacheRoomHistory,
  getDevModeCache: () => getDevModeCache,
  getPreviousProcessId: () => getPreviousProcessId,
  getProcessRestoreKey: () => getProcessRestoreKey,
  getRoomRestoreListKey: () => getRoomRestoreListKey,
  hasDevModeCache: () => hasDevModeCache,
  isDevMode: () => isDevMode,
  reloadFromCache: () => reloadFromCache,
  setDevMode: () => setDevMode,
  writeDevModeCache: () => writeDevModeCache
});
module.exports = __toCommonJS(DevMode_exports);
var import_fs = __toESM(require("fs"), 1);
var import_path = __toESM(require("path"), 1);
var import_schema = require("@colyseus/schema");
var import_Logger = require("../Logger.cjs");
var import_Debug = require("../Debug.cjs");
var import_MatchMaker = require("../MatchMaker.cjs");
var DEVMODE_CACHE_FILE_PATH = import_path.default.resolve(".devmode.json");
var isDevMode = false;
function hasDevModeCache() {
  return import_fs.default.existsSync(DEVMODE_CACHE_FILE_PATH);
}
function getDevModeCache() {
  return JSON.parse(import_fs.default.readFileSync(DEVMODE_CACHE_FILE_PATH, "utf8")) || {};
}
function writeDevModeCache(cache) {
  import_fs.default.writeFileSync(DEVMODE_CACHE_FILE_PATH, JSON.stringify(cache, null, 2), "utf8");
}
function setDevMode(bool) {
  isDevMode = bool;
}
async function reloadFromCache() {
  const roomHistoryList = Object.entries(await import_MatchMaker.presence.hgetall(getRoomRestoreListKey()));
  (0, import_Debug.debugDevMode)("rooms to restore: %i", roomHistoryList.length);
  for (const [roomId, value] of roomHistoryList) {
    const roomHistory = JSON.parse(value);
    (0, import_Debug.debugDevMode)("restoring room %s (%s)", roomHistory.roomName, roomId);
    const recreatedRoomListing = await (0, import_MatchMaker.handleCreateRoom)(roomHistory.roomName, roomHistory.clientOptions, roomId);
    const recreatedRoom = (0, import_MatchMaker.getLocalRoomById)(recreatedRoomListing.roomId);
    if (roomHistory.hasOwnProperty("state")) {
      try {
        const rawState = JSON.parse(roomHistory.state);
        import_Logger.logger.debug(`\u{1F4CB} room '${roomId}' state =>`, rawState);
        recreatedRoom.state.restore(rawState);
        if (roomHistory.nextRefId !== void 0) {
          const encoderRoot = recreatedRoom.state[import_schema.$changes]?.root;
          if (encoderRoot && roomHistory.nextRefId > encoderRoot["nextUniqueId"]) {
            encoderRoot["nextUniqueId"] = roomHistory.nextRefId;
          }
        }
      } catch (e) {
        (0, import_Debug.debugAndPrintError)(`\u274C couldn't restore room '${roomId}' state:
${e.stack}`);
      }
    }
    if (roomHistory.clients) {
      for (const clientData of roomHistory.clients) {
        const { sessionId, reconnectionToken } = clientData;
        if (!reconnectionToken) {
          continue;
        }
        await (0, import_MatchMaker.remoteRoomCall)(recreatedRoomListing.roomId, "_reserveSeat", [sessionId, {}, {}, recreatedRoom.seatReservationTimeout, false, reconnectionToken]);
      }
    }
    recreatedRoom.onRestoreRoom?.(roomHistory["cache"]);
    import_Logger.logger.debug(`\u{1F504} room '${roomId}' has been restored with ${roomHistory.clients?.length || 0} reserved seats: ${roomHistory.clients?.map((c) => c.sessionId).join(", ")}`);
  }
  if (roomHistoryList.length > 0) {
    import_Logger.logger.debug("\u2705", roomHistoryList.length, "room(s) have been restored.");
  }
}
async function cacheRoomHistory(rooms) {
  for (const room of Object.values(rooms)) {
    const roomHistoryResult = await import_MatchMaker.presence.hget(getRoomRestoreListKey(), room.roomId);
    if (roomHistoryResult) {
      try {
        const roomHistory = JSON.parse(roomHistoryResult);
        roomHistory["cache"] = room.onCacheRoom?.();
        (0, import_Debug.debugDevMode)("caching room %s (%s)", room.roomName, room.roomId);
        if (room.state) {
          roomHistory["state"] = JSON.stringify(room.state);
          const encoderRoot = room.state[import_schema.$changes]?.root;
          if (encoderRoot) {
            roomHistory["nextRefId"] = encoderRoot["nextUniqueId"];
          }
        }
        const activeClients = room.clients.map((client) => ({
          sessionId: client.sessionId,
          reconnectionToken: client.reconnectionToken
        }));
        const activeSessionIds = new Set(activeClients.map((c) => c.sessionId));
        const reservedSeats = Object.keys(room["_reservedSeats"]).filter((sessionId) => !activeSessionIds.has(sessionId)).map((sessionId) => ({
          sessionId,
          reconnectionToken: void 0
        }));
        roomHistory["clients"] = activeClients.concat(reservedSeats);
        await import_MatchMaker.presence.hset(getRoomRestoreListKey(), room.roomId, JSON.stringify(roomHistory));
        import_Logger.logger.debug(`\u{1F4BE} caching room '${room.roomId}' (clients: ${room.clients.length}, has state: ${roomHistory["state"] !== void 0 ? "yes" : "no"})`);
      } catch (e) {
        (0, import_Debug.debugAndPrintError)(`\u274C couldn't cache room '${room.roomId}', due to:
${e.stack}`);
      }
    }
  }
}
async function getPreviousProcessId(hostname = "") {
  return await import_MatchMaker.presence.hget(getProcessRestoreKey(), hostname);
}
function getRoomRestoreListKey() {
  return "roomhistory";
}
function getProcessRestoreKey() {
  return "processhistory";
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  cacheRoomHistory,
  getDevModeCache,
  getPreviousProcessId,
  getProcessRestoreKey,
  getRoomRestoreListKey,
  hasDevModeCache,
  isDevMode,
  reloadFromCache,
  setDevMode,
  writeDevModeCache
});