fix attaching callbacks to immediatelly available collections

Author: endel

package.json

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

src/decoder/strategy/StateCallbacks.ts

@@ -107,6 +107,8 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
     let currentOnAddCallback: Function | undefined;
 
     decoder.triggerChanges = function (allChanges: DataChange[]) {
+        // console.log("ALL CHANGES =>", allChanges);
+
         const uniqueRefIds = new Set<number>();
 
         for (let i = 0, l = allChanges.length; i < l; i++) {
@@ -290,7 +292,9 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                         const instance = context.instance?.[prop];
                         const onInstanceAvailable: OnInstanceAvailableCallback = (
                             (callback: (ref: Ref, existing: boolean) => void) => {
+                                console.log("onInstanceAvailable!!");
                                 const unbind = $(context.instance).listen(prop, (value, _) => {
+                                    console.log("prop changed!", prop);
                                     callback(value, false);
 
                                     // FIXME: by "unbinding" the callback here,
@@ -306,6 +310,7 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                                 }
                             }
                         );
+
                         return getProxy(metadataField.type, {
                             // make sure refId is available, otherwise need to wait for the instance to be available.
                             instance: ($root.refIds.get(instance) && instance),
@@ -344,10 +349,12 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
             };
 
             const onRemove = function (ref: Ref, callback: (value: any, key: any) => void) {
+                console.log("REGISTER ON REMOVE ON", $root.refIds.get(ref));
                 return $root.addCallback($root.refIds.get(ref), OPERATION.DELETE, callback);
             };
 
             const onChange = function (ref: Ref, callback: (value: any, key: any) => void) {
+                console.log("REGISTER ON CHANGE ON", $root.refIds.get(ref));
                 return $root.addCallback($root.refIds.get(ref), OPERATION.REPLACE, callback);
             };
 
@@ -373,7 +380,10 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                     }
                 },
                 onRemove: function(callback: (value, key) => void) {
-                    if (context.onInstanceAvailable) {
+                    if (context.instance) {
+                        return onRemove(context.instance, callback);
+
+                    } else if (context.onInstanceAvailable) {
                         // collection instance not received yet
                         let detachCallback = () => {};
 
@@ -382,13 +392,13 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                         });
 
                         return () => detachCallback();
-
-                    } else if (context.instance) {
-                        return onRemove(context.instance, callback);
                     }
                 },
                 onChange: function(callback: (value, key) => void) {
-                    if (context.onInstanceAvailable) {
+                    if (context.instance) {
+                        return onChange(context.instance, callback);
+
+                    } else if (context.onInstanceAvailable) {
                         // collection instance not received yet
                         let detachCallback = () => {};
 
@@ -397,9 +407,6 @@ export function getDecoderStateCallbacks<T extends Schema>(decoder: Decoder<T>):
                         });
 
                         return () => detachCallback();
-
-                    } else if (context.instance) {
-                        return onChange(context.instance, callback);
                     }
                 },
             }, {

test/ArraySchema.test.ts

@@ -1770,6 +1770,36 @@ describe("ArraySchema Tests", () => {
             assertDeepStrictEqualEncodeAll(state);
         });
 
+        it("clear should trigger callbacks properly", () => {
+            const state = new State();
+            const decodedState = new State();
+
+            decodedState.decode(state.encodeAll());
+            const $ = getCallbacks(decodedState);
+
+            let onAddCallCount = 0;
+            let onRemoveCallCount = 0;
+            let onChangeCallCount = 0;
+            $(decodedState).points.onAdd(() => { onAddCallCount++; });
+            $(decodedState).points.onRemove(() => { onRemoveCallCount++; });
+            $(decodedState).points.onChange(() => { onChangeCallCount++; });
+
+            state.points.push(new Point().assign({ x: 0, y: 0 }));
+            state.points.push(new Point().assign({ x: 1, y: 1 }));
+            decodedState.decode(state.encode());
+
+            assert.strictEqual(2, onAddCallCount);
+            assert.strictEqual(0, onRemoveCallCount);
+            assert.strictEqual(2, onChangeCallCount);
+
+            state.points.clear();
+            decodedState.decode(state.encode());
+
+            assert.strictEqual(2, onAddCallCount);
+            assert.strictEqual(2, onRemoveCallCount);
+            assert.strictEqual(4, onChangeCallCount);
+        });
+
         xit("should trigger onAdd callback only once after clearing and adding one item", () => {
             const state = new State();
             const decodedState = new State();