@colyseus/schema 3.0.0-alpha.34 → 3.0.0-alpha.35

package/src/types/custom/ArraySchema.ts

@@ -1,6 +1,6 @@
-import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $onDecodeEnd, $isNew } from "../symbols";
+import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $onDecodeEnd } from "../symbols";
 import type { Schema } from "../../Schema";
-import { ChangeTree } from "../../encoder/ChangeTree";
+import { ChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
 import { Collection } from "../HelperTypes";
@@ -70,6 +70,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             get: (obj, prop) => {
                 if (
                     typeof (prop) !== "symbol" &&
+                    // FIXME: d8 accuses this as low performance
                     !isNaN(prop as any) // https://stackoverflow.com/a/175787/892698
                 ) {
                     return this.items[prop];
@@ -89,7 +90,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
                             assertInstanceType(setValue, obj[$childType] as typeof Schema, obj, key);
 
                             if (obj.items[key as unknown as number] !== undefined) {
-                                if (setValue[$changes][$isNew]) {
+                                if (setValue[$changes].isNew) {
                                     this[$changes].indexedOperation(Number(key), OPERATION.MOVE_AND_ADD);
 
                                 } else {
@@ -99,7 +100,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
                                         this[$changes].indexedOperation(Number(key), OPERATION.MOVE);
                                     }
                                 }
-                            } else if (setValue[$changes][$isNew]) {
+                            } else if (setValue[$changes].isNew) {
                                 this[$changes].indexedOperation(Number(key), OPERATION.ADD);
                             }
 
@@ -138,7 +139,10 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
         this[$changes] = new ChangeTree(proxy);
         this[$changes].indexes = {};
-        this.push.apply(this, items);
+
+        if (items.length > 0) {
+            this.push(...items);
+        }
 
         return proxy;
     }
@@ -160,16 +164,22 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
     push(...values: V[]) {
         let length = this.tmpItems.length;
 
-        values.forEach((value, i) => {
-            // skip null values
+        const changeTree = this[$changes];
+
+        // values.forEach((value, i) => {
+
+        for (let i = 0, l = values.length; i < values.length; i++, length++) {
+            const value = values[i];
+
             if (value === undefined || value === null) {
+                // skip null values
                 return;
 
             } else if (typeof (value) === "object" && this[$childType]) {
                 assertInstanceType(value as any, this[$childType] as typeof Schema, this, i);
+                // TODO: move value[$changes]?.setParent() to this block.
             }
 
-            const changeTree = this[$changes];
             changeTree.indexedOperation(length, OPERATION.ADD, this.items.length);
 
             this.items.push(value);
@@ -180,9 +190,10 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             // (to avoid encoding "refId" operations before parent's "ADD" operation)
             //
             value[$changes]?.setParent(this, changeTree.root, length);
+        }
 
-            length++;
-        });
+        //     length++;
+        // });
 
         return length;
     }
@@ -209,6 +220,8 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         this[$changes].delete(index, undefined, this.items.length - 1);
 
         // this.tmpItems[index] = undefined;
+        // this.tmpItems.pop();
+
         this.deletedIndexes[index] = true;
 
         return this.items.pop();
@@ -270,10 +283,12 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
     clear() {
         // skip if already clear
-        if (this.items.length === 0) { return; }
+        if (this.items.length === 0) {
+            return;
+        }
 
         // discard previous operations.
-        const changeTree = this[$changes]
+        const changeTree = this[$changes];
 
         // discard children
         changeTree.forEachChild((changeTree, _) => {
@@ -285,9 +300,12 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             //
             // TODO: do not use [$changes] at decoding time.
             //
-            changeTree.root?.changes.delete(changeTree);
-            changeTree.root?.allChanges.delete(changeTree);
-            changeTree.root?.allFilteredChanges.delete(changeTree);
+            const root = changeTree.root;
+            if (root !== undefined) {
+                root.removeChangeFromChangeSet("changes", changeTree);
+                root.removeChangeFromChangeSet("allChanges", changeTree);
+                root.removeChangeFromChangeSet("allFilteredChanges", changeTree);
+            }
         });
 
         changeTree.discard(true);
@@ -338,6 +356,8 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
         changeTree.delete(index);
         changeTree.shiftAllChangeIndexes(-1, index);
 
+        // this.deletedIndexes[index] = true;
+
         return this.items.shift();
     }
 
@@ -437,9 +457,11 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
         // new index
         if (changeTree.isFiltered) {
-            changeTree.filteredChanges.set(this.items.length, OPERATION.ADD);
+            setOperationAtIndex(changeTree.filteredChanges, this.items.length);
+            // changeTree.filteredChanges[this.items.length] = OPERATION.ADD;
         } else {
-            changeTree.allChanges.set(this.items.length, OPERATION.ADD);
+            setOperationAtIndex(changeTree.allChanges, this.items.length);
+            // changeTree.allChanges[this.items.length] = OPERATION.ADD;
         }
 
         // FIXME: should we use OPERATION.MOVE here instead?

package/src/types/custom/MapSchema.ts

@@ -1,4 +1,4 @@
-import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex } from "../symbols";
+import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $numFields } from "../symbols";
 import { ChangeTree } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
@@ -15,6 +15,8 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
     protected $items: Map<K, V> = new Map<K, V>();
     protected $indexes: Map<number, K> = new Map<number, K>();
 
+    protected [$changes]: ChangeTree;
+
     static [$encoder] = encodeKeyValueOperation;
     static [$decoder] = decodeKeyValueOperation;
 
@@ -90,7 +92,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
 
         const index = (isReplace)
             ? changeTree.indexes[key]
-            : changeTree.indexes[-1] ?? 0;
+            : changeTree.indexes[$numFields] ?? 0;
 
         let operation: OPERATION = (isReplace)
             ? OPERATION.REPLACE
@@ -105,7 +107,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
         if (!isReplace) {
             this.$indexes.set(index, key);
             changeTree.indexes[key] = index;
-            changeTree.indexes[-1] = index + 1;
+            changeTree.indexes[$numFields] = index + 1;
 
         } else if (
             !isRef &&
@@ -208,8 +210,13 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
 
     protected [$onEncodeEnd]() {
         const changeTree = this[$changes];
-        const changes = changeTree.changes.entries();
-        for (const [fieldIndex, operation] of changes) {
+        const keys = Object.keys(changeTree.indexedOperations);
+
+        for (let i = 0, len = keys.length; i < len; i++) {
+            const key = keys[i];
+            const fieldIndex = Number(key);
+            const operation = changeTree.indexedOperations[key];
+
             if (operation === OPERATION.DELETE) {
                 const index = this[$getByIndex](fieldIndex) as string;
                 delete changeTree.indexes[index];

package/src/types/symbols.ts

@@ -7,8 +7,6 @@ export const $filter = Symbol("$filter");
 export const $getByIndex = Symbol("$getByIndex");
 export const $deleteByIndex = Symbol("$deleteByIndex");
 
-export const $descriptors = Symbol("$descriptors");
-
 /**
  * Used to hold ChangeTree instances whitin the structures
  */
@@ -20,12 +18,6 @@ export const $changes = Symbol('$changes');
  */
 export const $childType = Symbol('$childType');
 
-/**
- * Special ChangeTree property to identify new instances
- * (Once they're encoded, they're not new anymore)
- */
-export const $isNew = Symbol("$isNew");
-
 /**
  * Optional "discard" method for custom types (ArraySchema)
  * (Discards changes for next serialization)
@@ -35,4 +27,13 @@ export const $onEncodeEnd = Symbol('$onEncodeEnd');
 /**
  * When decoding, this method is called after the instance is fully decoded
  */
-export const $onDecodeEnd = Symbol("$onDecodeEnd");
+export const $onDecodeEnd = Symbol("$onDecodeEnd");
+
+/**
+ * Metadata
+ */
+export const $descriptors = Symbol("$descriptors");
+export const $numFields = "$__numFields";
+export const $refTypeFieldIndexes = "$__refTypeFieldIndexes";
+export const $viewFieldIndexes = "$__viewFieldIndexes";
+export const $fieldIndexesByViewTag = "$__fieldIndexesByViewTag";

package/src/utils.ts

@@ -27,13 +27,17 @@ export function dumpChanges(schema: Schema) {
         refs: []
     };
 
-    $root.changes.forEach((operations, changeTree) => {
+    // for (const refId in $root.changes) {
+    $root.changes.forEach(changeTree => {
+        const changes = changeTree.indexedOperations;
+
         dump.refs.push(`refId#${changeTree.refId}`);
-        operations.forEach((op, index) => {
+        for (const index in changes) {
+            const op = changes[index];
             const opName = OPERATION[op];
             if (!dump.ops[opName]) { dump.ops[opName] = 0; }
             dump.ops[OPERATION[op]]++;
-        });
+        }
     });
 
     return dump;