@duydang2311/ragemp-utils-server/dist/index.cjs

A collection of utilities for RAGE Multiplayer JavaScript module.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  RageMpStreamedMetaStore: () => RageMpStreamedMetaStore
});
module.exports = __toCommonJS(index_exports);

// src/streamed-meta.ts
var RageMpStreamedMetaStore = class _RageMpStreamedMetaStore {
  static #poolByType = /* @__PURE__ */ new Map([
    // ['blip', mp.blips],
    ["checkpoint", mp.checkpoints],
    ["colshape", mp.colshapes],
    // ['dummy', mp.dummies],
    ["marker", mp.markers],
    ["object", mp.objects],
    ["player", mp.players],
    ["vehicle", mp.vehicles],
    ["ped", mp.peds],
    ["textlabel", mp.labels]
  ]);
  #entityTypes;
  #metas = /* @__PURE__ */ new Map();
  #streamedEntitiesByPlayer = /* @__PURE__ */ new Map();
  #streamingPlayersByEntity = /* @__PURE__ */ new Map();
  #changeEventName;
  #streamedInEventName;
  #streamedOutEventName;
  #debug;
  constructor(options) {
    this.#entityTypes = new Set(options?.entityTypes ?? []);
    this.#changeEventName = options?.changeEventName ?? "streamedMeta.change";
    this.#streamedInEventName = options?.streamedInEventName ?? "streamedMeta.streamedIn";
    this.#streamedOutEventName = options?.streamedOutEventName ?? "streamedMeta.streamedOut";
    this.#debug = options?.debug ?? false;
  }
  init() {
    mp.events.add(
      this.#streamedInEventName,
      (player, entityType, remoteId) => {
        if (!this.#entityTypes.has(entityType)) {
          return;
        }
        if (this.#debug) {
          console.log(
            `[StreamedMetaStore] ${this.#streamedInEventName}, ${player.name}, ${entityType}, ${remoteId}`
          );
        }
        const entity = _RageMpStreamedMetaStore.#poolByType.get(entityType)?.at(remoteId);
        if (!entity) {
          return;
        }
        const streamedEntities = this.#streamedEntitiesByPlayer.get(player);
        if (streamedEntities) {
          streamedEntities.add(entity);
        } else {
          this.#streamedEntitiesByPlayer.set(
            player,
            /* @__PURE__ */ new Set([entity])
          );
        }
        const players = this.#streamingPlayersByEntity.get(entity);
        if (players) {
          players.add(player);
        } else {
          this.#streamingPlayersByEntity.set(
            entity,
            /* @__PURE__ */ new Set([player])
          );
        }
        const metas = this.#metas.get(
          this.#createMetaKey(entityType, remoteId)
        );
        if (metas) {
          for (const [name, value] of metas.entries()) {
            player.call(this.#changeEventName, [
              entityType,
              remoteId,
              name,
              value,
              void 0
            ]);
          }
        }
      }
    );
    mp.events.add(
      this.#streamedOutEventName,
      (player, entityType, remoteId) => {
        if (this.#debug) {
          console.log(
            `[StreamedMetaStore] ${this.#streamedOutEventName}, ${player.name}, ${entityType}, ${remoteId}`
          );
        }
        if (!this.#entityTypes.has(entityType)) {
          return;
        }
        const entity = _RageMpStreamedMetaStore.#poolByType.get(entityType)?.at(remoteId);
        if (!entity) {
          return;
        }
        const streamedEntities = this.#streamedEntitiesByPlayer.get(player);
        if (streamedEntities) {
          streamedEntities.delete(entity);
          if (streamedEntities.size === 0) {
            this.#streamedEntitiesByPlayer.delete(player);
          }
        }
        const players = this.#streamingPlayersByEntity.get(entity);
        if (players) {
          players.delete(player);
          if (players.size === 0) {
            this.#streamingPlayersByEntity.delete(entity);
          }
        }
      }
    );
    mp.events.add("entityDestroyed", (entity) => {
      if (!this.#entityTypes.has(entity.type)) {
        return;
      }
      if (this.#debug) {
        console.log(
          `[StreamedMetaStore] entityDestroyed, ${entity.type}, ${entity.id}`
        );
      }
      this.#metas.delete(this.#createMetaKey(entity.type, entity.id));
      const players = this.#streamingPlayersByEntity.get(entity);
      if (players) {
        for (const player of players) {
          const entities = this.#streamedEntitiesByPlayer.get(player);
          if (!entities) {
            continue;
          }
          entities.delete(entity);
          if (entities.size === 0) {
            this.#streamedEntitiesByPlayer.delete(player);
          }
        }
        this.#streamingPlayersByEntity.delete(entity);
      }
    });
  }
  set(entity, name, value) {
    this.#assertEntityType(entity.type);
    const key = this.#createMetaKey(entity.type, entity.id);
    const store = this.#metas.get(key);
    let previousValue;
    if (!store) {
      this.#metas.set(key, /* @__PURE__ */ new Map([[name, value]]));
    } else {
      previousValue = store.get(name);
      store.set(name, value);
    }
    if (value !== previousValue) {
      mp.players.call(
        this.#getPlayersStreamingEntity(entity),
        this.#changeEventName,
        [entity.type, entity.id, name, value, previousValue]
      );
    }
  }
  delete(entity, name) {
    this.#assertEntityType(entity.type);
    const key = this.#createMetaKey(entity.type, entity.id);
    const store = this.#metas.get(key);
    if (!store) {
      return false;
    }
    const previousValue = store.get(name);
    if (!store.delete(name)) {
      return false;
    }
    if (store.size === 0) {
      this.#metas.delete(key);
    }
    mp.players.call(
      this.#getPlayersStreamingEntity(entity),
      this.#changeEventName,
      [entity.type, entity.id, name, void 0, previousValue]
    );
    return true;
  }
  has(entity, name) {
    this.#assertEntityType(entity.type);
    return this.#metas.get(this.#createMetaKey(entity.type, entity.id))?.has(name) ?? false;
  }
  #createMetaKey(entityType, remoteId) {
    return `${entityType}:${remoteId}`;
  }
  #assertEntityType(type) {
    if (!this.#entityTypes.has(type)) {
      throw new Error(
        `Entity type ${type} is not supported by this store.`
      );
    }
  }
  #getPlayersStreamingEntity(entity) {
    const players = this.#streamingPlayersByEntity.get(entity);
    const arr = players ? Array.from(players) : [];
    if (entity.type === "player") {
      players?.add(entity);
    }
    if (entity.type === "player") {
      arr.push(entity);
    }
    return arr;
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  RageMpStreamedMetaStore
});
//# sourceMappingURL=index.cjs.map