@colyseus/schema 3.0.0-alpha.26 → 3.0.0-alpha.28

package/build/cjs/index.js

@@ -4039,7 +4039,8 @@ __decorate([
 function getDecoderStateCallbacks(decoder) {
     const $root = decoder.root;
     const callbacks = $root.callbacks;
-    let isTriggeringOnAdd = false;
+    const onAddCalls = new WeakMap();
+    let currentOnAddCallback;
     decoder.triggerChanges = function (allChanges) {
         const uniqueRefIds = new Set();
         for (let i = 0, l = allChanges.length; i < l; i++) {
@@ -4102,7 +4103,6 @@ function getDecoderStateCallbacks(decoder) {
                         }
                     }
                     // Handle DELETE_AND_ADD operations
-                    // FIXME: should we set "isTriggeringOnAdd" here?
                     if ((change.op & exports.OPERATION.ADD) === exports.OPERATION.ADD) {
                         const addCallbacks = $callbacks[exports.OPERATION.ADD];
                         for (let i = addCallbacks?.length - 1; i >= 0; i--) {
@@ -4112,12 +4112,10 @@ function getDecoderStateCallbacks(decoder) {
                 }
                 else if ((change.op & exports.OPERATION.ADD) === exports.OPERATION.ADD && change.previousValue === undefined) {
                     // triger onAdd
-                    isTriggeringOnAdd = true;
                     const addCallbacks = $callbacks[exports.OPERATION.ADD];
                     for (let i = addCallbacks?.length - 1; i >= 0; i--) {
                         addCallbacks[i](change.value, change.dynamicIndex ?? change.field);
                     }
-                    isTriggeringOnAdd = false;
                 }
                 // trigger onChange
                 if (change.value !== change.previousValue) {
@@ -4135,11 +4133,11 @@ function getDecoderStateCallbacks(decoder) {
         let isCollection = ((context.instance && typeof (context.instance['forEach']) === "function") ||
             (metadataOrType && typeof (metadataOrType[Symbol.metadata]) === "undefined"));
         if (metadata && !isCollection) {
-            const onAdd = function (ref, prop, callback, immediate) {
+            const onAddListen = function (ref, prop, callback, immediate) {
                 // immediate trigger
                 if (immediate &&
                     context.instance[prop] !== undefined &&
-                    !isTriggeringOnAdd // FIXME: This is a workaround (https://github.com/colyseus/schema/issues/147)
+                    !onAddCalls.has(currentOnAddCallback) // Workaround for https://github.com/colyseus/schema/issues/147
                 ) {
                     callback(context.instance[prop], undefined);
                 }
@@ -4151,13 +4149,13 @@ function getDecoderStateCallbacks(decoder) {
             return new Proxy({
                 listen: function listen(prop, callback, immediate = true) {
                     if (context.instance) {
-                        return onAdd(context.instance, prop, callback, immediate);
+                        return onAddListen(context.instance, prop, callback, immediate);
                     }
                     else {
                         // collection instance not received yet
                         let detachCallback = () => { };
                         context.onInstanceAvailable((ref, existing) => {
-                            detachCallback = onAdd(ref, prop, callback, immediate && existing);
+                            detachCallback = onAddListen(ref, prop, callback, immediate && existing && !onAddCalls.has(currentOnAddCallback));
                         });
                         return () => detachCallback();
                     }
@@ -4165,10 +4163,11 @@ function getDecoderStateCallbacks(decoder) {
                 onChange: function onChange(callback) {
                     return $root.addCallback($root.refIds.get(context.instance), exports.OPERATION.REPLACE, callback);
                 },
+                //
+                // TODO: refactor `bindTo()` implementation.
+                // There is room for improvement.
+                //
                 bindTo: function bindTo(targetObject, properties) {
-                    //
-                    // TODO: refactor this implementation. There is room for improvement here.
-                    //
                     if (!properties) {
                         properties = Object.keys(metadata);
                     }
@@ -4195,7 +4194,8 @@ function getDecoderStateCallbacks(decoder) {
                             }
                         });
                         return getProxy(metadata[prop].type, {
-                            instance,
+                            // make sure refId is available, otherwise need to wait for the instance to be available.
+                            instance: ($root.refIds.get(instance) && instance),
                             parentInstance: context.instance,
                             onInstanceAvailable,
                         });
@@ -4219,7 +4219,13 @@ function getDecoderStateCallbacks(decoder) {
                 if (immediate) {
                     ref.forEach((v, k) => callback(v, k));
                 }
-                return $root.addCallback($root.refIds.get(ref), exports.OPERATION.ADD, callback);
+                return $root.addCallback($root.refIds.get(ref), exports.OPERATION.ADD, (value, key) => {
+                    onAddCalls.set(callback, true);
+                    currentOnAddCallback = callback;
+                    callback(value, key);
+                    onAddCalls.delete(callback);
+                    currentOnAddCallback = undefined;
+                });
             };
             const onRemove = function (ref, callback) {
                 return $root.addCallback($root.refIds.get(ref), exports.OPERATION.DELETE, callback);
@@ -4230,19 +4236,17 @@ function getDecoderStateCallbacks(decoder) {
                     // https://github.com/colyseus/schema/issues/147
                     // If parent instance has "onAdd" registered, avoid triggering immediate callback.
                     //
-                    // FIXME: "isTriggeringOnAdd" is a workaround. We should find a better way to handle this.
-                    //
-                    if (context.onInstanceAvailable) {
+                    if (context.instance) {
+                        return onAdd(context.instance, callback, immediate && !onAddCalls.has(currentOnAddCallback));
+                    }
+                    else if (context.onInstanceAvailable) {
                         // collection instance not received yet
                         let detachCallback = () => { };
                         context.onInstanceAvailable((ref, existing) => {
-                            detachCallback = onAdd(ref, callback, immediate && existing && !isTriggeringOnAdd);
+                            detachCallback = onAdd(ref, callback, immediate && existing && !onAddCalls.has(currentOnAddCallback));
                         });
                         return () => detachCallback();
                     }
-                    else if (context.instance) {
-                        return onAdd(context.instance, callback, immediate && !isTriggeringOnAdd);
-                    }
                 },
                 onRemove: function (callback) {
                     if (context.onInstanceAvailable) {