Class ShallowMapPropertyPacket<K, V>

constructor

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

  Type Parameters

  • K
  • V extends ShallowObject

  Parameters

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

  Returns ShallowMapPropertyPacket<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.

deleteFields

• deleteFields(key: K, fields: (keyof V & string)[]): void

  Parameters

  • key: K
  • fields: (keyof V & string)[]

  Returns void

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 the property for changes. Unlike changed, this will fire the handler immediately if the value is already set. Else, it will wait for the value to be set and then fire the handler.

  Parameters

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

    The handler to call when the property changes

  Returns Connection

  A connection that can be disconnected to stop observing the property

patchEntry

• patchEntry(key: K, patch: Partial<V>, deletes?: (keyof V & string)[]): void

  Parameters

  • key: K
  • patch: Partial<V>
  • Optionaldeletes: (keyof V & string)[]

  Returns void

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