@colyseus/schema 3.0.42 → 3.0.43

package/src/encoder/Encoder.ts

@@ -10,7 +10,8 @@ import { Root } from "./Root";
 
 import type { StateView } from "./StateView";
 import type { Metadata } from "../Metadata";
-import type { ChangeSetName, ChangeTree } from "./ChangeTree";
+import type { ChangeSetName, ChangeTree, ChangeTreeList, ChangeTreeNode } from "./ChangeTree";
+import { createChangeTreeList } from "./ChangeTree";
 
 export class Encoder<T extends Schema = any> {
     static BUFFER_SIZE = (typeof(Buffer) !== "undefined") && Buffer.poolSize || 8 * 1024; // 8KB
@@ -54,11 +55,11 @@ export class Encoder<T extends Schema = any> {
     ): Buffer {
         const hasView = (view !== undefined);
         const rootChangeTree = this.state[$changes];
-        const changeTrees = this.root[changeSetName];
 
-        for (let i = 0, numChangeTrees = changeTrees.length; i < numChangeTrees; i++) {
-            const changeTree = changeTrees[i];
-            if (!changeTree) { continue; }
+        let current: ChangeTreeList | ChangeTreeNode = this.root[changeSetName];
+
+        while (current = current.next) {
+            const changeTree = current.changeTree;
 
             if (hasView) {
                 if (!view.isChangeTreeVisible(changeTree)) {
@@ -166,7 +167,9 @@ export class Encoder<T extends Schema = any> {
             ? this.root[field]
             : field;
 
-        rootChangeSet.forEach((changeTree) => {
+        let current = rootChangeSet.next;
+        while (current) {
+            const changeTree = current.changeTree;
             const changeSet = changeTree[field];
 
             const metadata: Metadata = changeTree.ref.constructor[Symbol.metadata];
@@ -179,7 +182,8 @@ export class Encoder<T extends Schema = any> {
                     op: OPERATION[op],
                 });
             }
-        });
+            current = current.next;
+        }
     }
 
     encodeView(view: StateView, sharedOffset: number, it: Iterator, bytes = this.sharedBuffer) {
@@ -242,22 +246,20 @@ export class Encoder<T extends Schema = any> {
 
     discardChanges() {
         // discard shared changes
-        let length = this.root.changes.length;
-        if (length > 0) {
-            while (length--) {
-                this.root.changes[length]?.endEncode('changes');
-            }
-            this.root.changes.length = 0;
+        let current = this.root.changes.next;
+        while (current) {
+            current.changeTree.endEncode('changes');
+            current = current.next;
         }
+        this.root.changes = createChangeTreeList();
 
         // discard filtered changes
-        length = this.root.filteredChanges.length;
-        if (length > 0) {
-            while (length--) {
-                this.root.filteredChanges[length]?.endEncode('filteredChanges');
-            }
-            this.root.filteredChanges.length = 0;
+        current = this.root.filteredChanges.next;
+        while (current) {
+            current.changeTree.endEncode('filteredChanges');
+            current = current.next;
         }
+        this.root.filteredChanges = createChangeTreeList();
     }
 
     tryEncodeTypeId (bytes: Buffer, baseType: typeof Schema, targetType: typeof Schema, it: Iterator) {

package/src/encoder/Root.ts

@@ -1,7 +1,6 @@
 import { OPERATION } from "../encoding/spec";
 import { TypeContext } from "../types/TypeContext";
-import { spliceOne } from "../types/utils";
-import { ChangeTree, enqueueChangeTree, setOperationAtIndex } from "./ChangeTree";
+import { ChangeTree, setOperationAtIndex, ChangeTreeList, createChangeTreeList, ChangeSetName } from "./ChangeTree";
 
 export class Root {
     protected nextUniqueId: number = 0;
@@ -10,12 +9,12 @@ export class Root {
     changeTrees: {[refId: number]: ChangeTree} = {};
 
     // all changes
-    allChanges: ChangeTree[] = [];
-    allFilteredChanges: ChangeTree[] = [];// TODO: do not initialize it if filters are not used
+    allChanges: ChangeTreeList = createChangeTreeList();
+    allFilteredChanges: ChangeTreeList = createChangeTreeList();// TODO: do not initialize it if filters are not used
 
     // pending changes to be encoded
-    changes: ChangeTree[] = [];
-    filteredChanges: ChangeTree[] = [];// TODO: do not initialize it if filters are not used
+    changes: ChangeTreeList = createChangeTreeList();
+    filteredChanges: ChangeTreeList = createChangeTreeList();// TODO: do not initialize it if filters are not used
 
     constructor(public types: TypeContext) { }
 
@@ -24,8 +23,10 @@ export class Root {
     }
 
     add(changeTree: ChangeTree) {
-        // FIXME: move implementation of `ensureRefId` to `Root` class
-        changeTree.ensureRefId();
+        // Assign unique `refId` to changeTree if it doesn't have one yet.
+        if (changeTree.refId === undefined) {
+            changeTree.refId = this.getNextUniqueId();
+        }
 
         const isNewChangeTree = (this.changeTrees[changeTree.refId] === undefined);
         if (isNewChangeTree) { this.changeTrees[changeTree.refId] = changeTree; }
@@ -53,6 +54,7 @@ export class Root {
         const refCount = (this.refCount[changeTree.refId]) - 1;
 
         if (refCount <= 0) {
+
             //
             // Only remove "root" reference if it's the last reference
             //
@@ -69,7 +71,20 @@ export class Root {
 
             this.refCount[changeTree.refId] = 0;
 
-            changeTree.forEachChild((child, _) => this.remove(child));
+            changeTree.forEachChild((child, _) => {
+                if (child.removeParent(changeTree.ref)) {
+                    if ((
+                        child.parentChain === undefined || // no parent, remove it
+                        (child.parentChain && this.refCount[child.refId] > 1) // parent is still in use, but has more than one reference, remove it
+                    )) {
+                        this.remove(child);
+
+                    } else if (child.parentChain) {
+                        // re-assigning a child of the same root, move it to the end
+                        this.moveToEndOfChanges(child);
+                    }
+                }
+            });
 
         } else {
             this.refCount[changeTree.refId] = refCount;
@@ -83,35 +98,79 @@ export class Root {
             // containing instance is not available, the Decoder will throw
             // "refId not found" error.
             //
-            if (changeTree.filteredChanges !== undefined) {
-                this.removeChangeFromChangeSet("filteredChanges", changeTree);
-                enqueueChangeTree(this, changeTree, "filteredChanges");
-            } else {
-                this.removeChangeFromChangeSet("changes", changeTree);
-                enqueueChangeTree(this, changeTree, "changes");
-            }
+            this.moveToEndOfChanges(changeTree);
+            changeTree.forEachChild((child, _) => this.moveToEndOfChanges(child));
         }
 
         return refCount;
     }
 
-    removeChangeFromChangeSet(changeSetName: "allChanges" | "changes" | "filteredChanges" | "allFilteredChanges", changeTree: ChangeTree) {
+    moveToEndOfChanges(changeTree: ChangeTree) {
+        if (changeTree.filteredChanges) {
+            this.moveToEndOfChangeTreeList("filteredChanges", changeTree);
+            this.moveToEndOfChangeTreeList("allFilteredChanges", changeTree);
+        } else {
+            this.moveToEndOfChangeTreeList("changes", changeTree);
+            this.moveToEndOfChangeTreeList("allChanges", changeTree);
+        }
+    }
+
+    moveToEndOfChangeTreeList(changeSetName: ChangeSetName, changeTree: ChangeTree): void {
         const changeSet = this[changeSetName];
-        const changeSetIndex = changeSet.indexOf(changeTree);
+        const node = changeTree[changeSetName].queueRootNode;
+        if (!node || node === changeSet.tail) return;
 
-        if (changeSetIndex !== -1) {
-            changeTree[changeSetName].queueRootIndex = -1;
-            changeSet[changeSetIndex] = undefined;
-            return true;
+        // Remove from current position
+        if (node.prev) {
+            node.prev.next = node.next;
+        } else {
+            changeSet.next = node.next;
+        }
+
+        if (node.next) {
+            node.next.prev = node.prev;
+        } else {
+            changeSet.tail = node.prev;
+        }
+
+        // Add to end
+        node.prev = changeSet.tail;
+        node.next = undefined;
+
+        if (changeSet.tail) {
+            changeSet.tail.next = node;
+        } else {
+            changeSet.next = node;
         }
 
-        // if (spliceOne(changeSet, changeSet.indexOf(changeTree))) {
-        //     changeTree[changeSetName].queueRootIndex = -1;
-        //     return true;
-        // }
+        changeSet.tail = node;
     }
 
-    clear() {
-        this.changes.length = 0;
+    protected removeChangeFromChangeSet(changeSetName: ChangeSetName, changeTree: ChangeTree) {
+        const changeSet = this[changeSetName];
+        const node = changeTree[changeSetName].queueRootNode;
+
+        if (node && node.changeTree === changeTree) {
+            // Remove the node from the linked list
+            if (node.prev) {
+                node.prev.next = node.next;
+            } else {
+                changeSet.next = node.next;
+            }
+
+            if (node.next) {
+                node.next.prev = node.prev;
+            } else {
+                changeSet.tail = node.prev;
+            }
+
+            changeSet.length--;
+
+            // Clear ChangeTree reference
+            changeTree[changeSetName].queueRootNode = undefined;
+            return true;
+        }
+
+        return false;
     }
 }

package/src/types/custom/ArraySchema.ts

@@ -1,6 +1,6 @@
 import { $changes, $childType, $decoder, $deleteByIndex, $onEncodeEnd, $encoder, $filter, $getByIndex, $onDecodeEnd } from "../symbols";
 import type { Schema } from "../../Schema";
-import { ChangeTree, debugChangeSet, deleteOperationAtIndex, enqueueChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
+import { ChangeTree, enqueueChangeTree, setOperationAtIndex } from "../../encoder/ChangeTree";
 import { OPERATION } from "../../encoding/spec";
 import { registerType } from "../registry";
 import { Collection } from "../HelperTypes";
@@ -156,8 +156,11 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
             }
         });
 
-        this[$changes] = new ChangeTree(proxy);
-        this[$changes].indexes = {};
+        Object.defineProperty(this, $changes, {
+            value: new ChangeTree(proxy),
+            enumerable: false,
+            writable: true,
+        });
 
         if (items.length > 0) {
             this.push(...items);
@@ -351,7 +354,6 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
     shift(): V | undefined {
         if (this.items.length === 0) { return undefined; }
 
-        // const index = Number(Object.keys(changeTree.indexes)[0]);
         const changeTree = this[$changes];
 
         const index = this.tmpItems.findIndex(item => item === this.items[0]);

package/src/types/custom/MapSchema.ts

@@ -43,8 +43,14 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
     }
 
     constructor (initialValues?: Map<K, V> | Record<K, V>) {
-        this[$changes] = new ChangeTree(this);
-        this[$changes].indexes = {};
+        const changeTree = new ChangeTree(this);
+        changeTree.indexes = {};
+
+        Object.defineProperty(this, $changes, {
+            value: changeTree,
+            enumerable: false,
+            writable: true,
+        });
 
         if (initialValues) {
             if (

package/src/types/symbols.ts

@@ -1,39 +1,39 @@
-export const $track = Symbol("$track");
-export const $encoder = Symbol("$encoder");
-export const $decoder = Symbol("$decoder");
+export const $track = "~track";
+export const $encoder = "~encoder";
+export const $decoder = "~decoder";
 
-export const $filter = Symbol("$filter");
+export const $filter = "~filter";
 
-export const $getByIndex = Symbol("$getByIndex");
-export const $deleteByIndex = Symbol("$deleteByIndex");
+export const $getByIndex = "~getByIndex";
+export const $deleteByIndex = "~deleteByIndex";
 
 /**
  * Used to hold ChangeTree instances whitin the structures
  */
-export const $changes = Symbol('$changes');
+export const $changes = '~changes';
 
 /**
  * Used to keep track of the type of the child elements of a collection
  * (MapSchema, ArraySchema, etc.)
  */
-export const $childType = Symbol('$childType');
+export const $childType = '~childType';
 
 /**
  * Optional "discard" method for custom types (ArraySchema)
  * (Discards changes for next serialization)
  */
-export const $onEncodeEnd = Symbol('$onEncodeEnd');
+export const $onEncodeEnd = '~onEncodeEnd';
 
 /**
  * When decoding, this method is called after the instance is fully decoded
  */
-export const $onDecodeEnd = Symbol("$onDecodeEnd");
+export const $onDecodeEnd = "~onDecodeEnd";
 
 /**
  * Metadata
  */
-export const $descriptors = Symbol("$descriptors");
-export const $numFields = "$__numFields";
-export const $refTypeFieldIndexes = "$__refTypeFieldIndexes";
-export const $viewFieldIndexes = "$__viewFieldIndexes";
+export const $descriptors = "~descriptors";
+export const $numFields = "~__numFields";
+export const $refTypeFieldIndexes = "~__refTypeFieldIndexes";
+export const $viewFieldIndexes = "~__viewFieldIndexes";
 export const $fieldIndexesByViewTag = "$__fieldIndexesByViewTag";

package/src/utils.ts

@@ -28,9 +28,14 @@ export function dumpChanges(schema: Schema) {
     };
 
     // for (const refId in $root.changes) {
-    $root.changes.forEach(changeTree => {
+    let current = $root.changes.next;
+    while (current) {
+        const changeTree = current.changeTree;
         // skip if ChangeTree is undefined
-        if (changeTree === undefined)  { return; }
+        if (changeTree === undefined)  {
+            current = current.next;
+            continue;
+        }
 
         const changes = changeTree.indexedOperations;
 
@@ -41,7 +46,8 @@ export function dumpChanges(schema: Schema) {
             if (!dump.ops[opName]) { dump.ops[opName] = 0; }
             dump.ops[OPERATION[op]]++;
         }
-    });
+        current = current.next;
+    }
 
     return dump;
 }