@nativewrappers/common 0.0.129 → 0.0.131

package/common-game/common/net/NetworkedMap.js

@@ -70,10 +70,12 @@ class NetworkedMap extends Map {
   }
   /*
    * Resyncs the entire map to the client, useful for if there's a mismatch in the clients map (when multiple players change things, in cases like inventories)
-   *
-   * NOTE: This doesn't check that the player is already subscribed to the map, you should do your own due-diligence to only call this for players already subscribed
    */
   resync(source2) {
+    if (!this.#subscribers.has(source2)) {
+      console.error(`[NetworkedMap:resync] Tried to call resync on a source that wasn't already subscribed`);
+      return;
+    }
     const packed_data = msgpack_pack([this.#syncName, [[4 /* Init */, this.size === 0 ? [] : Array.from(this)]]]);
     TriggerClientEventInternal(
       `${GlobalData.CurrentResource}:syncChanges`,
@@ -83,7 +85,7 @@ class NetworkedMap extends Map {
     );
   }
   /*
-   * Adds a new subscriber to the map
+   * Adds a new subscriber to the map, this will automatically call resync on the client.
    */
   addSubscriber(source2) {
     this.#subscribers.add(source2);
@@ -155,10 +157,45 @@ class NetworkedMap extends Map {
       ln(value);
     }
   }
+  /*
+   * Adds {@param value} to the map under {@param key}, {@param value} will automatically be turned into a proxy
+   * object and the NetworkedMap will automatically send events on SubValue changes.
+   * ```ts
+   *
+   *  const map = new NetworkedMap<number, { name:string , quantity: number, obj: { nested_obj_description: string }}>("someUniqueName");
+   *
+   *  const item = {
+   *    name: "magic_item",
+   *    quantity: 1,
+   *    obj: {
+   *      something_description: "Will never be updated after init"
+   *    }
+   *  }
+   *
+   *  // automatically converts `item` into a proxy object
+   *  map.set(1, item)
+   *
+   *  // if you immediately change the value this will not be recognized, you have to get the object again from the map
+   *  item.quantity = 2;
+   *
+   *  // reactive object
+   *  const proxy_object = map.get(1)!;
+   *
+   *  // sub value change will be sent to the client on the next network tick.
+   *  proxy_object.quantity = 2;
+   *
+   *  // NOTE: this doesn't work on deeply nested objects, it will only work on anything assigned to the first object
+   *  // This update will never be sent to the client, similar to how state bags work.
+   *  proxy_object.obj.nested_obj_description = "Some new value"
+   * ```
+   * i.e. if you have { name: "magic_item", quantity: 1}
+   * if you change the item.quantity field this will automatically be sync'd to the client, is only one depth deep
+   * so if you have { obj: { some_quantity: 1 } } setting item.obj.some_quantity will not update the client.
+   */
   set(key, value) {
     let v = value;
     if (value instanceof Object) {
-      const curMap = this;
+      const curThis = this;
       const objectChangeHandler = {
         get(target, prop, reciever) {
           return Reflect.get(target, prop, reciever);
@@ -166,9 +203,9 @@ class NetworkedMap extends Map {
         set(target, p, newValue, receiver) {
           const success = Reflect.set(target, p, newValue, receiver);
           if (success) {
-            curMap.#pushChangeForListener(key, target);
+            curThis.#pushChangeForListener(key, target);
             $SERVER: {
-              curMap.#queuedChanges.push([0 /* SubValueChanged */, key, p, newValue]);
+              curThis.#queuedChanges.push([0 /* SubValueChanged */, key, p, newValue]);
             }
           }
           return success;

package/net/NetworkedMap.js

@@ -70,10 +70,12 @@ class NetworkedMap extends Map {
   }
   /*
    * Resyncs the entire map to the client, useful for if there's a mismatch in the clients map (when multiple players change things, in cases like inventories)
-   *
-   * NOTE: This doesn't check that the player is already subscribed to the map, you should do your own due-diligence to only call this for players already subscribed
    */
   resync(source2) {
+    if (!this.#subscribers.has(source2)) {
+      console.error(`[NetworkedMap:resync] Tried to call resync on a source that wasn't already subscribed`);
+      return;
+    }
     const packed_data = msgpack_pack([this.#syncName, [[4 /* Init */, this.size === 0 ? [] : Array.from(this)]]]);
     TriggerClientEventInternal(
       `${GlobalData.CurrentResource}:syncChanges`,
@@ -83,7 +85,7 @@ class NetworkedMap extends Map {
     );
   }
   /*
-   * Adds a new subscriber to the map
+   * Adds a new subscriber to the map, this will automatically call resync on the client.
    */
   addSubscriber(source2) {
     this.#subscribers.add(source2);
@@ -155,10 +157,45 @@ class NetworkedMap extends Map {
       ln(value);
     }
   }
+  /*
+   * Adds {@param value} to the map under {@param key}, {@param value} will automatically be turned into a proxy
+   * object and the NetworkedMap will automatically send events on SubValue changes.
+   * ```ts
+   *
+   *  const map = new NetworkedMap<number, { name:string , quantity: number, obj: { nested_obj_description: string }}>("someUniqueName");
+   *
+   *  const item = {
+   *    name: "magic_item",
+   *    quantity: 1,
+   *    obj: {
+   *      something_description: "Will never be updated after init"
+   *    }
+   *  }
+   *
+   *  // automatically converts `item` into a proxy object
+   *  map.set(1, item)
+   *
+   *  // if you immediately change the value this will not be recognized, you have to get the object again from the map
+   *  item.quantity = 2;
+   *
+   *  // reactive object
+   *  const proxy_object = map.get(1)!;
+   *
+   *  // sub value change will be sent to the client on the next network tick.
+   *  proxy_object.quantity = 2;
+   *
+   *  // NOTE: this doesn't work on deeply nested objects, it will only work on anything assigned to the first object
+   *  // This update will never be sent to the client, similar to how state bags work.
+   *  proxy_object.obj.nested_obj_description = "Some new value"
+   * ```
+   * i.e. if you have { name: "magic_item", quantity: 1}
+   * if you change the item.quantity field this will automatically be sync'd to the client, is only one depth deep
+   * so if you have { obj: { some_quantity: 1 } } setting item.obj.some_quantity will not update the client.
+   */
   set(key, value) {
     let v = value;
     if (value instanceof Object) {
-      const curMap = this;
+      const curThis = this;
       const objectChangeHandler = {
         get(target, prop, reciever) {
           return Reflect.get(target, prop, reciever);
@@ -166,9 +203,9 @@ class NetworkedMap extends Map {
         set(target, p, newValue, receiver) {
           const success = Reflect.set(target, p, newValue, receiver);
           if (success) {
-            curMap.#pushChangeForListener(key, target);
+            curThis.#pushChangeForListener(key, target);
             $SERVER: {
-              curMap.#queuedChanges.push([0 /* SubValueChanged */, key, p, newValue]);
+              curThis.#queuedChanges.push([0 /* SubValueChanged */, key, p, newValue]);
             }
           }
           return success;

package/package.json

@@ -8,7 +8,7 @@
   ],
   "license": "MIT",
   "type": "module",
-  "version": "0.0.129",
+  "version": "0.0.131",
   "repository": {
     "type": "git",
     "url": "https://github.com/nativewrappers/nativewrappers.git"