avoid calling .removeRef() on items already flagged for garbage collection.

Author: endel

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/schema",
-  "version": "3.0.17",
+  "version": "3.0.18",
   "description": "Binary state serializer with delta encoding for games",
   "bin": {
     "schema-codegen": "./bin/schema-codegen",

src/decoder/ReferenceTracker.ts

@@ -103,15 +103,20 @@ export class ReferenceTracker {
                 for (const index in metadata) {
                     const field = metadata[index as any as number].name;
                     const childRefId = typeof(ref[field]) === "object" && this.refIds.get(ref[field]);
-                    if (childRefId) {
+                    if (childRefId && !this.deletedRefs.has(childRefId)) {
                         this.removeRef(childRefId);
                     }
                 }
 
             } else {
                 if (typeof (Object.values(ref[$childType])[0]) === "function") {
                     Array.from((ref as MapSchema).values())
-                        .forEach((child) => this.removeRef(this.refIds.get(child)));
+                        .forEach((child) => {
+                            const childRefId = this.refIds.get(child);
+                            if (!this.deletedRefs.has(childRefId)) {
+                                this.removeRef(childRefId);
+                            }
+                        });
                 }
             }
 

test/MapSchema.test.ts

@@ -1,7 +1,7 @@
 import * as assert from "assert";
 
-import { State, Player, getCallbacks, createInstanceFromReflection, getDecoder, getEncoder, assertDeepStrictEqualEncodeAll } from "./Schema";
-import { MapSchema, type, Schema, ArraySchema, Reflection, $changes } from "../src";
+import { State, Player, getCallbacks, createInstanceFromReflection, getDecoder, getEncoder, assertDeepStrictEqualEncodeAll, assertRefIdCounts } from "./Schema";
+import { MapSchema, type, Schema, ArraySchema, Reflection, $changes, SetSchema, entity } from "../src";
 import { nanoid } from "nanoid";
 
 describe("Type: MapSchema", () => {
@@ -727,6 +727,40 @@ describe("Type: MapSchema", () => {
         assert.deepStrictEqual(map.toJSON(), previousMap.toJSON());
     });
 
+    it("should trigger warning: 'trying to remove refId with 0 refCount'", () => {
+        enum Synergy { NORMAL = "NORMAL", GRASS = "GRASS", FIRE = "FIRE", WATER = "WATER", ELECTRIC = "ELECTRIC", FIGHTING = "FIGHTING", }
+        class Pokemon extends Schema {
+            @type("string") name: string;
+            @type({ set: "string" }) types = new SetSchema<Synergy>();
+        }
+        @entity
+        class Pikachu extends Pokemon {
+            name = "Pikachu";
+            types = new SetSchema<Synergy>([Synergy.ELECTRIC]);
+        }
+        class Player extends Schema {
+            @type({ map: Pokemon }) board = new MapSchema<Pokemon>();
+        }
+        class State extends Schema {
+            @type({ map: Player }) players = new MapSchema<Player>();
+        }
+
+        const state = new State();
+        const decodedState = createInstanceFromReflection(state);
+
+        const player = new Player();
+		state.players.set("one", player);
+		player.board.set("1", new Pikachu());
+
+        decodedState.decode(state.encode());
+
+        player.board.delete("1");
+        decodedState.decode(state.encode());
+
+        assertRefIdCounts(state, decodedState);
+        assertDeepStrictEqualEncodeAll(state);
+    });
+
     xit("move instance between keys in the same patch", () => {
         //
         // TODO: test $onEncodeEnd of MapSchema. Is $onEncodeEnd of MapSchema even necessary?

test/Schema.ts

@@ -48,7 +48,7 @@ export function assertRefIdCounts(source: Schema, target: Schema) {
     for (const refId in encoder.root.refCount) {
         const encoderRefCount = encoder.root.refCount[refId];
         const decoderRefCount = decoder.root.refCounts[refId] ?? 0;
-        assert.strictEqual(encoderRefCount, decoderRefCount, `refCount mismatch for ${refId}`);
+        assert.strictEqual(encoderRefCount, decoderRefCount, `refCount mismatch for refId: ${refId}`);
     }
 }