@colyseus/schema 3.0.42 → 3.0.44

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, Ref } 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; }
@@ -46,11 +47,14 @@ export class Root {
 
         this.refCount[changeTree.refId] = (previousRefCount || 0) + 1;
 
+        // console.log("ADD", { refId: changeTree.refId, refCount: this.refCount[changeTree.refId] });
+
         return isNewChangeTree;
     }
 
-    remove(changeTree: ChangeTree) {
+    remove(changeTree: ChangeTree, parent?: Ref) {
         const refCount = (this.refCount[changeTree.refId]) - 1;
+        // console.log("REMOVE", { refId: changeTree.refId, refCount });
 
         if (refCount <= 0) {
             //
@@ -69,7 +73,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, changeTree.ref);
+
+                    } 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 +100,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/encoder/StateView.ts

@@ -43,13 +43,14 @@ export class StateView {
     // TODO: allow to set multiple tags at once
     add(obj: Ref, tag: number = DEFAULT_VIEW_TAG, checkIncludeParent: boolean = true) {
         const changeTree: ChangeTree = obj?.[$changes];
+        const parentChangeTree = changeTree.parent;
 
         if (!changeTree) {
             console.warn("StateView#add(), invalid object:", obj);
-            return this;
+            return false;
 
         } else if (
-            !changeTree.parent &&
+            !parentChangeTree &&
             changeTree.refId !== 0 // allow root object
         ) {
             /**
@@ -76,20 +77,38 @@ export class StateView {
         // add parent ChangeTree's
         // - if it was invisible to this view
         // - if it were previously filtered out
-        if (checkIncludeParent && changeTree.parent) {
+        if (checkIncludeParent && parentChangeTree) {
             this.addParentOf(changeTree, tag);
         }
 
-        //
-        // TODO: when adding an item of a MapSchema, the changes may not
-        // be set (only the parent's changes are set)
-        //
         let changes = this.changes.get(changeTree.refId);
         if (changes === undefined) {
             changes = {};
+            // FIXME / OPTIMIZE: do not add if no changes are needed
             this.changes.set(changeTree.refId, changes);
         }
 
+        let isChildAdded = false;
+
+        //
+        // Add children of this ChangeTree first.
+        // If successful, we must link the current ChangeTree to the child.
+        //
+        changeTree.forEachChild((change, index) => {
+            // Do not ADD children that don't have the same tag
+            if (
+                metadata &&
+                metadata[index].tag !== undefined &&
+                metadata[index].tag !== tag
+            ) {
+                return;
+            }
+
+            if (this.add(change.ref, tag, false)) {
+                isChildAdded = true;
+            }
+        });
+
         // set tag
         if (tag !== DEFAULT_VIEW_TAG) {
             if (!this.tags) {
@@ -111,12 +130,14 @@ export class StateView {
                 }
             });
 
-        } else {
-            const isInvisible = this.invisible.has(changeTree);
+        } else if (!changeTree.isNew || isChildAdded) {
+            // new structures will be added as part of .encode() call, no need to force it to .encodeView()
             const changeSet = (changeTree.filteredChanges !== undefined)
                 ? changeTree.allFilteredChanges
                 : changeTree.allChanges;
 
+            const isInvisible = this.invisible.has(changeTree);
+
             for (let i = 0, len = changeSet.operations.length; i < len; i++) {
                 const index = changeSet.operations[i];
                 if (index === undefined) { continue; } // skip "undefined" indexes
@@ -124,33 +145,20 @@ export class StateView {
                 const op = changeTree.indexedOperations[index] ?? OPERATION.ADD;
                 const tagAtIndex = metadata?.[index].tag;
                 if (
-                    !changeTree.isNew && // new structures will be added as part of .encode() call, no need to force it to .encodeView()
+                    op !== OPERATION.DELETE &&
                     (
                         isInvisible || // if "invisible", include all
                         tagAtIndex === undefined || // "all change" with no tag
                         tagAtIndex === tag // tagged property
-                    ) &&
-                    op !== OPERATION.DELETE
+                    )
                 ) {
                     changes[index] = op;
+                    isChildAdded = true; // FIXME: assign only once
                 }
             }
         }
 
-        // Add children of this ChangeTree to this view
-        changeTree.forEachChild((change, index) => {
-            // Do not ADD children that don't have the same tag
-            if (
-                metadata &&
-                metadata[index].tag !== undefined &&
-                metadata[index].tag !== tag
-            ) {
-                return;
-            }
-            this.add(change.ref, tag, false);
-        });
-
-        return this;
+        return isChildAdded;
     }
 
     protected addParentOf(childChangeTree: ChangeTree, tag: number) {

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";
@@ -120,7 +120,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
                             if (previousValue !== undefined) {
                                 // remove root reference from previous value
-                                previousValue[$changes].root?.remove(previousValue[$changes]);
+                                previousValue[$changes].root?.remove(previousValue[$changes], obj);
                             }
 
                         } else {
@@ -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);
@@ -307,7 +310,7 @@ export class ArraySchema<V = any> implements Array<V>, Collection<number, V> {
 
         // remove children references
         changeTree.forEachChild((childChangeTree, _) => {
-            changeTree.root?.remove(childChangeTree);
+            changeTree.root?.remove(childChangeTree, this);
         });
 
         changeTree.discard(true);
@@ -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/CollectionSchema.ts

@@ -118,7 +118,7 @@ export class CollectionSchema<V=any> implements Collection<K, V>{
 
         // remove children references
         changeTree.forEachChild((childChangeTree, _) => {
-            changeTree.root?.remove(childChangeTree);
+            changeTree.root?.remove(childChangeTree, this);
         });
 
         // clear previous indexes

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 (
@@ -108,7 +114,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
 
                 // remove reference from previous value
                 if (previousValue !== undefined) {
-                    previousValue[$changes].root?.remove(previousValue[$changes]);
+                    previousValue[$changes].root?.remove(previousValue[$changes], this);
                 }
             }
 
@@ -157,7 +163,7 @@ export class MapSchema<V=any, K extends string = string> implements Map<K, V>, C
 
         // remove children references
         changeTree.forEachChild((childChangeTree, _) => {
-            changeTree.root?.remove(childChangeTree);
+            changeTree.root?.remove(childChangeTree, this);
         });
 
         // clear previous indexes

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 $fieldIndexesByViewTag = "$__fieldIndexesByViewTag";
+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;
 }