@colyseus/schema 3.0.26 → 3.0.28

package/build/cjs/index.js

@@ -1,5 +1,7 @@
 'use strict';
 
+require('util');
+
 const SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
 const TYPE_ID = 213;
 /**
@@ -973,10 +975,18 @@ function setOperationAtIndex(changeSet, index) {
     }
 }
 function deleteOperationAtIndex(changeSet, index) {
-    const operationsIndex = changeSet.indexes[index];
-    if (operationsIndex !== undefined) {
-        changeSet.operations[operationsIndex] = undefined;
+    let operationsIndex = changeSet.indexes[index];
+    if (operationsIndex === undefined) {
+        //
+        // if index is not found, we need to find the last operation
+        // FIXME: this is not very efficient
+        //
+        // > See "should allow consecutive splices (same place)" tests
+        //
+        operationsIndex = Object.values(changeSet.indexes).at(-1);
+        index = Object.entries(changeSet.indexes).find(([_, value]) => value === operationsIndex)?.[0];
     }
+    changeSet.operations[operationsIndex] = undefined;
     delete changeSet.indexes[index];
 }
 function enqueueChangeTree(root, changeTree, changeSet, queueRootIndex = changeTree[changeSet].queueRootIndex) {
@@ -1161,14 +1171,9 @@ class ChangeTree {
     }
     _shiftAllChangeIndexes(shiftIndex, startIndex = 0, changeSet) {
         const newIndexes = {};
+        let newKey = 0;
         for (const key in changeSet.indexes) {
-            const index = changeSet.indexes[key];
-            if (index > startIndex) {
-                newIndexes[Number(key) + shiftIndex] = index;
-            }
-            else {
-                newIndexes[key] = index;
-            }
+            newIndexes[newKey++] = changeSet.indexes[key];
         }
         changeSet.indexes = newIndexes;
         for (let i = 0; i < changeSet.operations.length; i++) {
@@ -1358,25 +1363,35 @@ class ChangeTree {
         const refType = Metadata.isValidInstance(this.ref)
             ? this.ref.constructor
             : this.ref[$childType];
-        if (!Metadata.isValidInstance(parent)) {
-            const parentChangeTree = parent[$changes];
+        let parentChangeTree;
+        let parentIsCollection = !Metadata.isValidInstance(parent);
+        if (parentIsCollection) {
+            parentChangeTree = parent[$changes];
             parent = parentChangeTree.parent;
             parentIndex = parentChangeTree.parentIndex;
         }
+        else {
+            parentChangeTree = parent[$changes];
+        }
         const parentConstructor = parent.constructor;
         let key = `${this.root.types.getTypeId(refType)}`;
         if (parentConstructor) {
             key += `-${this.root.types.schemas.get(parentConstructor)}`;
         }
         key += `-${parentIndex}`;
+        const fieldHasViewTag = parentConstructor?.[Symbol.metadata]?.[$viewFieldIndexes]?.includes(parentIndex);
         this.isFiltered = parent[$changes].isFiltered // in case parent is already filtered
             || this.root.types.parentFiltered[key]
-            || parentConstructor?.[Symbol.metadata]?.[$viewFieldIndexes]?.includes(parentIndex);
+            || fieldHasViewTag;
         //
         // "isFiltered" may not be imedialely available during `change()` due to the instance not being attached to the root yet.
         // when it's available, we need to enqueue the "changes" changeset into the "filteredChanges" changeset.
         //
         if (this.isFiltered) {
+            this.isVisibilitySharedWithParent = (parentChangeTree.isFiltered &&
+                typeof (refType) !== "string" &&
+                !fieldHasViewTag &&
+                parentIsCollection);
             if (!this.filteredChanges) {
                 this.filteredChanges = createChangeSet();
                 this.allFilteredChanges = createChangeSet();
@@ -1512,6 +1527,7 @@ const encodeArray = function (encoder, bytes, changeTree, field, operation, it,
     }
     const type = changeTree.getType(field);
     const value = changeTree.getValue(field, isEncodeAll);
+    // console.log({ type, field, value });
     // console.log("encodeArray -> ", {
     //     ref: changeTree.ref.constructor.name,
     //     field,
@@ -1833,8 +1849,7 @@ class ArraySchema {
     static [(_a$4 = $encoder, _b$4 = $decoder, $filter)](ref, index, view) {
         return (!view ||
             typeof (ref[$childType]) === "string" ||
-            // view.items.has(ref[$getByIndex](index)[$changes])
-            view.visible.has(ref['tmpItems'][index]?.[$changes]));
+            view.isChangeTreeVisible(ref['tmpItems'][index]?.[$changes]));
     }
     static is(type) {
         return (
@@ -1990,8 +2005,6 @@ class ArraySchema {
             return undefined;
         }
         this[$changes].delete(index, undefined, this.items.length - 1);
-        // this.tmpItems[index] = undefined;
-        // this.tmpItems.pop();
         this.deletedIndexes[index] = true;
         return this.items.pop();
     }
@@ -2142,31 +2155,50 @@ class ArraySchema {
      * @param deleteCount The number of elements to remove.
      * @param insertItems Elements to insert into the array in place of the deleted elements.
      */
-    splice(start, deleteCount = this.items.length - start, ...insertItems) {
+    splice(start, deleteCount, ...insertItems) {
         const changeTree = this[$changes];
+        const itemsLength = this.items.length;
         const tmpItemsLength = this.tmpItems.length;
         const insertCount = insertItems.length;
         // build up-to-date list of indexes, excluding removed values.
         const indexes = [];
         for (let i = 0; i < tmpItemsLength; i++) {
-            // if (this.tmpItems[i] !== undefined) {
             if (this.deletedIndexes[i] !== true) {
                 indexes.push(i);
             }
         }
-        // delete operations at correct index
-        for (let i = start; i < start + deleteCount; i++) {
-            const index = indexes[i];
-            changeTree.delete(index);
-            // this.tmpItems[index] = undefined;
-            this.deletedIndexes[index] = true;
+        if (itemsLength > start) {
+            // if deleteCount is not provided, delete all items from start to end
+            if (deleteCount === undefined) {
+                deleteCount = itemsLength - start;
+            }
+            //
+            // delete operations at correct index
+            //
+            for (let i = start; i < start + deleteCount; i++) {
+                const index = indexes[i];
+                changeTree.delete(index, exports.OPERATION.DELETE);
+                this.deletedIndexes[index] = true;
+            }
         }
-        // force insert operations
-        for (let i = 0; i < insertCount; i++) {
-            const addIndex = indexes[start] + i;
-            changeTree.indexedOperation(addIndex, exports.OPERATION.ADD);
-            // set value's parent/root
-            insertItems[i][$changes]?.setParent(this, changeTree.root, addIndex);
+        else {
+            // not enough items to delete
+            deleteCount = 0;
+        }
+        // insert operations
+        if (insertCount > 0) {
+            if (insertCount > deleteCount) {
+                console.error("Inserting more elements than deleting during ArraySchema#splice()");
+                throw new Error("ArraySchema#splice(): insertCount must be equal or lower than deleteCount.");
+            }
+            for (let i = 0; i < insertCount; i++) {
+                const addIndex = (indexes[start] ?? itemsLength) + i;
+                changeTree.indexedOperation(addIndex, (this.deletedIndexes[addIndex])
+                    ? exports.OPERATION.DELETE_AND_ADD
+                    : exports.OPERATION.ADD);
+                // set value's parent/root
+                insertItems[i][$changes]?.setParent(this, changeTree.root, addIndex);
+            }
         }
         //
         // delete exceeding indexes from "allChanges"
@@ -2174,6 +2206,16 @@ class ArraySchema {
         //
         if (deleteCount > insertCount) {
             changeTree.shiftAllChangeIndexes(-(deleteCount - insertCount), indexes[start + insertCount]);
+            // debugChangeSet("AFTER SHIFT indexes", changeTree.allChanges);
+        }
+        //
+        // FIXME: this code block is duplicated on ChangeTree
+        //
+        if (changeTree.filteredChanges !== undefined) {
+            enqueueChangeTree(changeTree.root, changeTree, 'filteredChanges');
+        }
+        else {
+            enqueueChangeTree(changeTree.root, changeTree, 'changes');
         }
         return this.items.splice(start, deleteCount, ...insertItems);
     }
@@ -2429,9 +2471,6 @@ class ArraySchema {
             : this.deletedIndexes[index]
                 ? this.items[index]
                 : this.tmpItems[index] || this.items[index];
-        // return (isEncodeAll)
-        //     ? this.items[index]
-        //     : this.tmpItems[index] ?? this.items[index];
     }
     [$deleteByIndex](index) {
         this.items[index] = undefined;
@@ -2491,7 +2530,7 @@ class MapSchema {
     static [(_a$3 = $encoder, _b$3 = $decoder, $filter)](ref, index, view) {
         return (!view ||
             typeof (ref[$childType]) === "string" ||
-            view.visible.has((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes]));
+            view.isChangeTreeVisible((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes]));
     }
     static is(type) {
         return type['map'] !== undefined;
@@ -3108,7 +3147,7 @@ class Schema {
         }
         else if (tag === DEFAULT_VIEW_TAG) {
             // view pass: default tag
-            return view.visible.has(ref[$changes]);
+            return view.isChangeTreeVisible(ref[$changes]);
         }
         else {
             // view pass: custom tag
@@ -3321,7 +3360,7 @@ class CollectionSchema {
     static [(_a$1 = $encoder, _b$1 = $decoder, $filter)](ref, index, view) {
         return (!view ||
             typeof (ref[$childType]) === "string" ||
-            view.visible.has((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes]));
+            view.isChangeTreeVisible((ref[$getByIndex](index) ?? ref.deletedItems[index])[$changes]));
     }
     static is(type) {
         return type['collection'] !== undefined;
@@ -3795,18 +3834,17 @@ class Encoder {
                 continue;
             }
             if (hasView) {
-                if (!view.visible.has(changeTree)) {
+                if (!view.isChangeTreeVisible(changeTree)) {
+                    // console.log("MARK AS INVISIBLE:", { ref: changeTree.ref.constructor.name, refId: changeTree.refId, raw: changeTree.ref.toJSON() });
                     view.invisible.add(changeTree);
                     continue; // skip this change tree
                 }
-                else {
-                    view.invisible.delete(changeTree); // remove from invisible list
-                }
+                view.invisible.delete(changeTree); // remove from invisible list
             }
-            const operations = changeTree[changeSetName];
+            const changeSet = changeTree[changeSetName];
             const ref = changeTree.ref;
             // TODO: avoid iterating over change tree if no changes were made
-            const numChanges = operations.operations.length;
+            const numChanges = changeSet.operations.length;
             if (numChanges === 0) {
                 continue;
             }
@@ -3821,7 +3859,7 @@ class Encoder {
                 encode.number(buffer, changeTree.refId, it);
             }
             for (let j = 0; j < numChanges; j++) {
-                const fieldIndex = operations.operations[j];
+                const fieldIndex = changeSet.operations[j];
                 const operation = (fieldIndex < 0)
                     ? Math.abs(fieldIndex) // "pure" operation without fieldIndex (e.g. CLEAR, REVERSE, etc.)
                     : (isEncodeAll)
@@ -4935,6 +4973,25 @@ class StateView {
         // clear items array
         this.items.length = 0;
     }
+    isChangeTreeVisible(changeTree) {
+        let isVisible = this.visible.has(changeTree);
+        //
+        // TODO: avoid checking for parent visibility, most of the time it's not needed
+        // See test case: 'should not be required to manually call view.add() items to child arrays without @view() tag'
+        //
+        if (!isVisible && changeTree.isVisibilitySharedWithParent) {
+            // console.log("CHECK AGAINST PARENT...", {
+            //     ref: changeTree.ref.constructor.name,
+            //     refId: changeTree.refId,
+            //     parent: changeTree.parent.constructor.name,
+            // });
+            if (this.visible.has(changeTree.parent[$changes])) {
+                this.visible.add(changeTree);
+                isVisible = true;
+            }
+        }
+        return isVisible;
+    }
 }
 
 registerType("map", { constructor: MapSchema });