@colyseus/schema 3.0.28 → 3.0.30

package/build/esm/index.mjs

@@ -957,6 +957,9 @@ const Metadata = {
             fields[metadata[i].name] = metadata[i].type;
         }
         return fields;
+    },
+    hasViewTagAtIndex(metadata, index) {
+        return metadata?.[$viewFieldIndexes]?.includes(index);
     }
 };
 
@@ -1377,7 +1380,7 @@ class ChangeTree {
             key += `-${this.root.types.schemas.get(parentConstructor)}`;
         }
         key += `-${parentIndex}`;
-        const fieldHasViewTag = parentConstructor?.[Symbol.metadata]?.[$viewFieldIndexes]?.includes(parentIndex);
+        const fieldHasViewTag = Metadata.hasViewTagAtIndex(parentConstructor?.[Symbol.metadata], parentIndex);
         this.isFiltered = parent[$changes].isFiltered // in case parent is already filtered
             || this.root.types.parentFiltered[key]
             || fieldHasViewTag;
@@ -1520,7 +1523,7 @@ const encodeArray = function (encoder, bytes, changeTree, field, operation, it,
     // encode index
     encode.number(bytes, refOrIndex, it);
     // Do not encode value for DELETE operations
-    if (operation === OPERATION.DELETE) {
+    if (operation === OPERATION.DELETE || operation === OPERATION.DELETE_BY_REFID) {
         return;
     }
     const type = changeTree.getType(field);
@@ -1741,10 +1744,14 @@ const decodeArray = function (decoder, bytes, it, ref, allChanges) {
     else if (operation === OPERATION.ADD_BY_REFID) {
         const refId = decode.number(bytes, it);
         const itemByRefId = decoder.root.refs.get(refId);
-        // use existing index, or push new value
-        index = (itemByRefId)
-            ? ref.findIndex((value) => value === itemByRefId)
-            : ref.length;
+        // if item already exists, use existing index
+        if (itemByRefId) {
+            index = ref.findIndex((value) => value === itemByRefId);
+        }
+        // fallback to use last index
+        if (index === -1 || index === undefined) {
+            index = ref.length;
+        }
     }
     else {
         index = decode.number(bytes, it);
@@ -1863,6 +1870,7 @@ class ArraySchema {
         this.items = [];
         this.tmpItems = [];
         this.deletedIndexes = {};
+        this.isMovingItems = false;
         Object.defineProperty(this, $childType, {
             value: undefined,
             enumerable: false,
@@ -1890,31 +1898,38 @@ class ArraySchema {
                         if (setValue[$changes]) {
                             assertInstanceType(setValue, obj[$childType], obj, key);
                             const previousValue = obj.items[key];
-                            if (previousValue !== undefined) {
-                                if (setValue[$changes].isNew) {
-                                    this[$changes].indexedOperation(Number(key), OPERATION.MOVE_AND_ADD);
-                                }
-                                else {
-                                    if ((obj[$changes].getChange(Number(key)) & OPERATION.DELETE) === OPERATION.DELETE) {
-                                        this[$changes].indexedOperation(Number(key), OPERATION.DELETE_AND_MOVE);
+                            if (!obj.isMovingItems) {
+                                obj.$changeAt(Number(key), setValue);
+                            }
+                            else {
+                                if (previousValue !== undefined) {
+                                    if (setValue[$changes].isNew) {
+                                        obj[$changes].indexedOperation(Number(key), OPERATION.MOVE_AND_ADD);
                                     }
                                     else {
-                                        this[$changes].indexedOperation(Number(key), OPERATION.MOVE);
+                                        if ((obj[$changes].getChange(Number(key)) & OPERATION.DELETE) === OPERATION.DELETE) {
+                                            obj[$changes].indexedOperation(Number(key), OPERATION.DELETE_AND_MOVE);
+                                        }
+                                        else {
+                                            obj[$changes].indexedOperation(Number(key), OPERATION.MOVE);
+                                        }
                                     }
                                 }
+                                else if (setValue[$changes].isNew) {
+                                    obj[$changes].indexedOperation(Number(key), OPERATION.ADD);
+                                }
+                                setValue[$changes].setParent(this, obj[$changes].root, key);
+                            }
+                            if (previousValue !== undefined) {
                                 // remove root reference from previous value
                                 previousValue[$changes].root?.remove(previousValue[$changes]);
                             }
-                            else if (setValue[$changes].isNew) {
-                                this[$changes].indexedOperation(Number(key), OPERATION.ADD);
-                            }
-                            setValue[$changes].setParent(this, obj[$changes].root, key);
                         }
                         else {
                             obj.$changeAt(Number(key), setValue);
                         }
-                        this.items[key] = setValue;
-                        this.tmpItems[key] = setValue;
+                        obj.items[key] = setValue;
+                        obj.tmpItems[key] = setValue;
                     }
                     return true;
                 }
@@ -2022,8 +2037,12 @@ class ArraySchema {
         if (this.items[index] === value) {
             return;
         }
+        const operation = (this.items[index] !== undefined)
+            ? typeof (value) === "object"
+                ? OPERATION.DELETE_AND_ADD // schema child
+                : OPERATION.REPLACE // primitive
+            : OPERATION.ADD;
         const changeTree = this[$changes];
-        const operation = changeTree.indexes?.[index]?.op ?? OPERATION.ADD;
         changeTree.change(index, operation);
         //
         // set value's parent after the value is set
@@ -2140,11 +2159,13 @@ class ArraySchema {
      * ```
      */
     sort(compareFn = DEFAULT_SORT) {
+        this.isMovingItems = true;
         const changeTree = this[$changes];
         const sortedItems = this.items.sort(compareFn);
         // wouldn't OPERATION.MOVE make more sense here?
         sortedItems.forEach((_, i) => changeTree.change(i, OPERATION.REPLACE));
         this.tmpItems.sort(compareFn);
+        this.isMovingItems = false;
         return this;
     }
     /**
@@ -2457,6 +2478,37 @@ class ArraySchema {
         // @ts-ignore
         return this.items.toSpliced.apply(copy, arguments);
     }
+    shuffle() {
+        return this.move((_) => {
+            let currentIndex = this.items.length;
+            while (currentIndex != 0) {
+                let randomIndex = Math.floor(Math.random() * currentIndex);
+                currentIndex--;
+                [this[currentIndex], this[randomIndex]] = [this[randomIndex], this[currentIndex]];
+            }
+        });
+    }
+    /**
+     * Allows to move items around in the array.
+     *
+     * Example:
+     *     state.cards.move((cards) => {
+     *         [cards[4], cards[3]] = [cards[3], cards[4]];
+     *         [cards[3], cards[2]] = [cards[2], cards[3]];
+     *         [cards[2], cards[0]] = [cards[0], cards[2]];
+     *         [cards[1], cards[1]] = [cards[1], cards[1]];
+     *         [cards[0], cards[0]] = [cards[0], cards[0]];
+     *     })
+     *
+     * @param cb
+     * @returns
+     */
+    move(cb) {
+        this.isMovingItems = true;
+        cb(this);
+        this.isMovingItems = false;
+        return this;
+    }
     [($getByIndex)](index, isEncodeAll = false) {
         //
         // TODO: avoid unecessary `this.tmpItems` check during decoding.