Class ExactMapPropertyPacket<K, V>

constructor

• new ExactMapPropertyPacket<K, V>(
      id: string,
      initialEntries?: ReadonlyMap<K, V>,
      isUnreliable?: boolean,
      meta?: Many<
          [
              "tuple",
              [
                  payload: [
                      "object_raw",
                      (
                          | ["full", ["boolean"]]
                          | [
                              "changes",
                              [
                                  "array",
                                  ((...) extends (...) ? (...) : (...)) extends true
                                      ? [(...), (...), (...), (...)]
                                      : [(...), (...)],
                              ],
                          ]
                      )[],
                  ],
              ],
              undefined,
          ],
      >,
  ): ExactMapPropertyPacket<K, V>

  Type Parameters

  • K
  • V

  Parameters

  • id: string
  • OptionalinitialEntries: ReadonlyMap<K, V>
  • OptionalisUnreliable: boolean
  • Optionalmeta: Many<
        [
            "tuple",
            [
                payload: [
                    "object_raw",
                    (
                        | ["full", ["boolean"]]
                        | [
                            "changes",
                            [
                                "array",
                                ((...) extends (...) ? (...) : (...)) extends true
                                    ? [(...), (...), (...), (...)]
                                    : [(...), (...)],
                            ],
                        ]
                    )[],
                ],
            ],
            undefined,
        ],
    >

  Returns ExactMapPropertyPacket<K, V>

ReadonlyclassName

ReadonlysignalPacket

clear

• clear(): void

  Clears the map.

  Returns void

clearFor

• clearFor(player: Player): void

  Clears the map for a specific player.

  Parameters

  • player: Player

    The player for whom to clear the map.

  Returns void

deleteEntry

• deleteEntry(key: K): boolean

  Removes an entry from the map if present.

  Parameters

  • key: K

    The key of the entry to remove.

  Returns boolean

  True if the entry was present and removed, false otherwise.

destroy

• destroy(): void

  Cleans up any resources used by the packet.

  Returns void

get

• get(player?: Player): Map<K, V>

  Retrieves the entire map. If a player is provided, retrieves the map specific to that player if it exists.

  Parameters

  • Optionalplayer: Player

    The player for whom to retrieve the map, or undefined for the global map.

  Returns Map<K, V>

getEntry

• getEntry(key: K): undefined | V

  Retrieves the value for a specific key.

  Parameters

  • key: K

  Returns undefined | V

getSnapshot

• getSnapshot(): Map<K, V>

  Returns a new Map snapshot of the current state.

  Returns Map<K, V>

observe

• observe(
      handler: (snapshot: Map<K, V>, diff: DiffPayload<K, V>) => void,
  ): Connection

  Observes map changes. Handler receives the latest snapshot and the diff payload.

  Parameters

  • handler: (snapshot: Map<K, V>, diff: DiffPayload<K, V>) => void

  Returns Connection

set

• set(entries: Map<K, V>): void

  Replaces the entire map with the provided entries, sending only the computed diff to clients.

  Parameters

  • entries: Map<K, V>

    The new entries to set in the map.

  Returns void

setEntries

• setEntries(entries: Map<K, V>): void

  Sets multiple entries in the map, keeping existing entries intact.

  Parameters

  • entries: Map<K, V>

    The entries to set in the map.

  Returns void

setEntry

• setEntry(key: K, value: V): void

  Sets a single entry in the map, keeping existing entries intact.

  Parameters

  • key: K

    The key of the entry to set.
  • value: V

    The value to set for the specified key.

  Returns void

setFor

• setFor(player: Player, value: Map<K, V>): void

  Sets the value of the map for a specific player.

  Parameters

  • player: Player

    The player to set the value for
  • value: Map<K, V>

    The new value of the property

  Returns void