@colyseus/schema 3.0.0-alpha.31 → 3.0.0-alpha.32

package/build/esm/index.mjs

@@ -471,7 +471,6 @@ class ChangeTree {
         changeSet.set(index, operation ?? OPERATION.DELETE);
         // remove `root` reference
         if (previousValue && previousValue[$changes]) {
-            previousValue[$changes].root = undefined;
             //
             // FIXME: this.root is "undefined"
             //
@@ -482,7 +481,13 @@ class ChangeTree {
             //
             // (the property descriptors should NOT be used at decoding time. only at encoding time.)
             //
-            this.root?.remove(previousValue[$changes]);
+            const refCount = this.root?.remove(previousValue[$changes]);
+            //
+            // Only remove "root" reference if it's the last reference
+            //
+            if (refCount <= 0) {
+                previousValue[$changes].root = undefined;
+            }
         }
         //
         // FIXME: this is looking a bit ugly (and repeated from `.change()`)
@@ -861,21 +866,11 @@ var encode = /*#__PURE__*/Object.freeze({
     writeFloat64: writeFloat64
 });
 
-function encodeValue(encoder, bytes, 
-// ref: Ref,
-type, value, 
-// field: string | number,
-operation, it) {
+function encodeValue(encoder, bytes, type, value, operation, it) {
     if (typeof (type) === "string") {
-        //
-        // Primitive values
-        //
-        // assertType(value, type as string, ref as Schema, field);
         encode[type]?.(bytes, value, it);
     }
     else if (type[Symbol.metadata] !== undefined) {
-        // // TODO: move this to the `@type()` annotation
-        // assertInstanceType(value, type as typeof Schema, ref as Schema, field);
         //
         // Encode refId for this instance.
         // The actual instance is going to be encoded on next `changeTree` iteration.
@@ -887,14 +882,6 @@ operation, it) {
         }
     }
     else {
-        // //
-        // // Custom type (MapSchema, ArraySchema, etc)
-        // //
-        // const definition = getType(Object.keys(type)[0]);
-        // //
-        // // ensure a ArraySchema has been provided
-        // //
-        // assertInstanceType(ref[field], definition.constructor, ref as Schema, field);
         //
         // Encode refId for this instance.
         // The actual instance is going to be encoded on next `changeTree` iteration.
@@ -914,14 +901,10 @@ const encodeSchemaOperation = function (encoder, bytes, changeTree, index, opera
         return;
     }
     const ref = changeTree.ref;
-    const metadata = ref['constructor'][Symbol.metadata];
+    const metadata = ref.constructor[Symbol.metadata];
     const field = metadata[index];
     // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, 
-    // ref,
-    metadata[index].type, ref[field.name], 
-    // index,
-    operation, it);
+    encodeValue(encoder, bytes, metadata[index].type, ref[field.name], operation, it);
 };
 /**
  * Used for collections (MapSchema, CollectionSchema, SetSchema)
@@ -944,7 +927,7 @@ const encodeKeyValueOperation = function (encoder, bytes, changeTree, index, ope
     //
     // encode "alias" for dynamic fields (maps)
     //
-    if ((operation & OPERATION.ADD) == OPERATION.ADD) { // ADD or DELETE_AND_ADD
+    if ((operation & OPERATION.ADD) === OPERATION.ADD) { // ADD or DELETE_AND_ADD
         if (typeof (ref['set']) === "function") {
             //
             // MapSchema dynamic key
@@ -953,8 +936,8 @@ const encodeKeyValueOperation = function (encoder, bytes, changeTree, index, ope
             string$1(bytes, dynamicIndex, it);
         }
     }
-    const type = changeTree.getType(index);
-    const value = changeTree.getValue(index);
+    const type = ref[$childType];
+    const value = ref[$getByIndex](index);
     // try { throw new Error(); } catch (e) {
     //     // only print if not coming from Reflection.ts
     //     if (!e.stack.includes("src/Reflection.ts")) {
@@ -968,11 +951,7 @@ const encodeKeyValueOperation = function (encoder, bytes, changeTree, index, ope
     //     }
     // }
     // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, 
-    // ref,
-    type, value, 
-    // index,
-    operation, it);
+    encodeValue(encoder, bytes, type, value, operation, it);
 };
 /**
  * Used for collections (MapSchema, ArraySchema, etc.)
@@ -1016,11 +995,7 @@ const encodeArray = function (encoder, bytes, changeTree, field, operation, it,
     //     items: ref.toJSON(),
     // });
     // TODO: inline this function call small performance gain
-    encodeValue(encoder, bytes, 
-    // ref,
-    type, value, 
-    // field,
-    operation, it);
+    encodeValue(encoder, bytes, type, value, operation, it);
 };
 
 /**
@@ -1326,7 +1301,9 @@ function decodeValue(decoder, operation, ref, index, type, bytes, it, allChanges
             if (!value) {
                 value = decoder.createInstanceOfType(childType);
             }
-            $root.addRef(refId, value, (value !== previousValue));
+            $root.addRef(refId, value, (value !== previousValue || // increment ref count if value has changed
+                (operation === OPERATION.DELETE_AND_ADD && value === previousValue) // increment ref count if the same instance is being added again
+            ));
         }
     }
     else if (typeof (type) === "string") {
@@ -3473,24 +3450,36 @@ class Root {
         return this.nextUniqueId++;
     }
     add(changeTree) {
-        const refCount = this.refCount.get(changeTree) || 0;
-        this.refCount.set(changeTree, refCount + 1);
+        const previousRefCount = this.refCount.get(changeTree);
+        if (previousRefCount === 0) {
+            //
+            // When a ChangeTree is re-added, it means that it was previously removed.
+            // We need to re-add all changes to the `changes` map.
+            //
+            changeTree.allChanges.forEach((operation, index) => {
+                changeTree.changes.set(index, operation);
+            });
+        }
+        const refCount = (previousRefCount || 0) + 1;
+        this.refCount.set(changeTree, refCount);
+        return refCount;
     }
     remove(changeTree) {
-        const refCount = this.refCount.get(changeTree);
-        if (refCount <= 1) {
+        const refCount = (this.refCount.get(changeTree)) - 1;
+        if (refCount <= 0) {
             this.allChanges.delete(changeTree);
             this.changes.delete(changeTree);
             if (changeTree.isFiltered || changeTree.isPartiallyFiltered) {
                 this.allFilteredChanges.delete(changeTree);
                 this.filteredChanges.delete(changeTree);
             }
-            this.refCount.delete(changeTree);
+            this.refCount.set(changeTree, 0);
         }
         else {
-            this.refCount.set(changeTree, refCount - 1);
+            this.refCount.set(changeTree, refCount);
         }
         changeTree.forEachChild((child, _) => this.remove(child));
+        return refCount;
     }
     clear() {
         this.changes.clear();
@@ -3524,7 +3513,7 @@ class Encoder {
         const shouldClearChanges = !isEncodeAll && !hasView;
         for (const [changeTree, changes] of changeTrees.entries()) {
             const ref = changeTree.ref;
-            const ctor = ref['constructor'];
+            const ctor = ref.constructor;
             const encoder = ctor[$encoder];
             const filter = ctor[$filter];
             // try { throw new Error(); } catch (e) {
@@ -3548,8 +3537,7 @@ class Encoder {
                 buffer[it.offset++] = SWITCH_TO_STRUCTURE & 255;
                 number$1(buffer, changeTree.refId, it);
             }
-            const changesIterator = changes.entries();
-            for (const [fieldIndex, operation] of changesIterator) {
+            for (const [fieldIndex, operation] of changes.entries()) {
                 //
                 // first pass (encodeAll), identify "filtered" operations without encoding them
                 // they will be encoded per client, based on their view.
@@ -3575,7 +3563,12 @@ class Encoder {
                 encoder(this, buffer, changeTree, fieldIndex, operation, it, isEncodeAll, hasView);
             }
             // if (shouldClearChanges) {
-            //     changeTree.endEncode();
+            //     // changeTree.endEncode();
+            //     changeTree.changes.clear();
+            //     // ArraySchema and MapSchema have a custom "encode end" method
+            //     changeTree.ref[$onEncodeEnd]?.();
+            //     // Not a new instance anymore
+            //     delete changeTree[$isNew];
             // }
         }
         if (it.offset > buffer.byteLength) {