@colyseus/schema 3.0.29 → 3.0.30

package/build/cjs/index.js

@@ -1872,6 +1872,7 @@ class ArraySchema {
         this.items = [];
         this.tmpItems = [];
         this.deletedIndexes = {};
+        this.isMovingItems = false;
         Object.defineProperty(this, $childType, {
             value: undefined,
             enumerable: false,
@@ -1899,31 +1900,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), exports.OPERATION.MOVE_AND_ADD);
-                                }
-                                else {
-                                    if ((obj[$changes].getChange(Number(key)) & exports.OPERATION.DELETE) === exports.OPERATION.DELETE) {
-                                        this[$changes].indexedOperation(Number(key), exports.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), exports.OPERATION.MOVE_AND_ADD);
                                     }
                                     else {
-                                        this[$changes].indexedOperation(Number(key), exports.OPERATION.MOVE);
+                                        if ((obj[$changes].getChange(Number(key)) & exports.OPERATION.DELETE) === exports.OPERATION.DELETE) {
+                                            obj[$changes].indexedOperation(Number(key), exports.OPERATION.DELETE_AND_MOVE);
+                                        }
+                                        else {
+                                            obj[$changes].indexedOperation(Number(key), exports.OPERATION.MOVE);
+                                        }
                                     }
                                 }
+                                else if (setValue[$changes].isNew) {
+                                    obj[$changes].indexedOperation(Number(key), exports.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), exports.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;
                 }
@@ -2031,8 +2039,12 @@ class ArraySchema {
         if (this.items[index] === value) {
             return;
         }
+        const operation = (this.items[index] !== undefined)
+            ? typeof (value) === "object"
+                ? exports.OPERATION.DELETE_AND_ADD // schema child
+                : exports.OPERATION.REPLACE // primitive
+            : exports.OPERATION.ADD;
         const changeTree = this[$changes];
-        const operation = changeTree.indexes?.[index]?.op ?? exports.OPERATION.ADD;
         changeTree.change(index, operation);
         //
         // set value's parent after the value is set
@@ -2149,11 +2161,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, exports.OPERATION.REPLACE));
         this.tmpItems.sort(compareFn);
+        this.isMovingItems = false;
         return this;
     }
     /**
@@ -2466,6 +2480,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.